Added the usb-send-delay-threshold quirk

This quirk limits usb-send-delay effect only to requests which size
exceeds the threshold.

See #95 for discussion and details.

Author: alexpevzner

ipp-usb.8

@@ -320,6 +320,10 @@ Don't use more that N USB interfaces, even if more is available\.
 .br
 Delay between low\-level USB send\-to\-device requests (this is not the same as \fBrequest\-delay\fR, which inserts delays between the whole HTTP\-level requests)\.
 .IP "\(bu" 4
+\fBusb\-send\-delay\-threshold = DELAY\fR
+.br
+\fBusb\-send\-delay\fR only applied if USB send\-to\-device request size exceeds this threshold\.
+.IP "\(bu" 4
 \fBzlp\-recv\-hack = true | false\fR
 .br
 Some enterprise\-level HP devices, during the initialization phase (which can last several minutes), may respond with an HTTP 503 status or similar, which is expected\. However, the response body may be truncated (typically, the terminating '\en' is lost)\. In such cases, \fBipp\-usb\fR will wait indefinitely for a response to maintain synchronization with the device\.

ipp-usb.8.md

@@ -407,6 +407,10 @@ The following parameters are defined:
      the same as `request-delay`, which inserts delays between the
      whole HTTP-level requests).
 
+   * `usb-send-delay-threshold = DELAY`<br>
+     `usb-send-delay` only applied if USB send-to-device request size
+     exceeds this threshold.
+
    * `zlp-recv-hack = true | false`<br>
      Some enterprise-level HP devices, during the initialization phase
      (which can last several minutes), may respond with an HTTP 503

quirks.go

@@ -35,55 +35,58 @@ type Quirk struct {
 // Quirk names. Use these constants instead of literal strings,
 // so compiler will catch a mistake:
 const (
-	QuirkNmBlacklist         = "blacklist"
-	QuirkNmBuggyIppResponses = "buggy-ipp-responses"
-	QuirkNmDisableFax        = "disable-fax"
-	QuirkNmIgnoreIppStatus   = "ignore-ipp-status"
-	QuirkNmInitDelay         = "init-delay"
-	QuirkNmInitReset         = "init-reset"
-	QuirkNmInitRetryPartial  = "init-retry-partial"
-	QuirkNmInitTimeout       = "init-timeout"
-	QuirkNmRequestDelay      = "request-delay"
-	QuirkNmUsbMaxInterfaces  = "usb-max-interfaces"
-	QuirkNmUsbSendDelay      = "usb-send-delay"
-	QuirkNmZlpRecvHack       = "zlp-recv-hack"
-	QuirkNmZlpSend           = "zlp-send"
+	QuirkNmBlacklist             = "blacklist"
+	QuirkNmBuggyIppResponses     = "buggy-ipp-responses"
+	QuirkNmDisableFax            = "disable-fax"
+	QuirkNmIgnoreIppStatus       = "ignore-ipp-status"
+	QuirkNmInitDelay             = "init-delay"
+	QuirkNmInitReset             = "init-reset"
+	QuirkNmInitRetryPartial      = "init-retry-partial"
+	QuirkNmInitTimeout           = "init-timeout"
+	QuirkNmRequestDelay          = "request-delay"
+	QuirkNmUsbMaxInterfaces      = "usb-max-interfaces"
+	QuirkNmUsbSendDelayThreshold = "usb-send-delay-threshold"
+	QuirkNmUsbSendDelay          = "usb-send-delay"
+	QuirkNmZlpRecvHack           = "zlp-recv-hack"
+	QuirkNmZlpSend               = "zlp-send"
 )
 
 // quirkParse maps quirk names into appropriate parsing methods,
 // which defines value syntax and resulting type.
 var quirkParse = map[string]func(*Quirk) error{
-	QuirkNmBlacklist:         (*Quirk).parseBool,
-	QuirkNmBuggyIppResponses: (*Quirk).parseQuirkBuggyIppRsp,
-	QuirkNmDisableFax:        (*Quirk).parseBool,
-	QuirkNmIgnoreIppStatus:   (*Quirk).parseBool,
-	QuirkNmInitDelay:         (*Quirk).parseDuration,
-	QuirkNmInitReset:         (*Quirk).parseQuirkResetMethod,
-	QuirkNmInitRetryPartial:  (*Quirk).parseBool,
-	QuirkNmInitTimeout:       (*Quirk).parseDuration,
-	QuirkNmRequestDelay:      (*Quirk).parseDuration,
-	QuirkNmUsbMaxInterfaces:  (*Quirk).parseUint,
-	QuirkNmUsbSendDelay:      (*Quirk).parseDuration,
-	QuirkNmZlpRecvHack:       (*Quirk).parseBool,
-	QuirkNmZlpSend:           (*Quirk).parseBool,
+	QuirkNmBlacklist:             (*Quirk).parseBool,
+	QuirkNmBuggyIppResponses:     (*Quirk).parseQuirkBuggyIppRsp,
+	QuirkNmDisableFax:            (*Quirk).parseBool,
+	QuirkNmIgnoreIppStatus:       (*Quirk).parseBool,
+	QuirkNmInitDelay:             (*Quirk).parseDuration,
+	QuirkNmInitReset:             (*Quirk).parseQuirkResetMethod,
+	QuirkNmInitRetryPartial:      (*Quirk).parseBool,
+	QuirkNmInitTimeout:           (*Quirk).parseDuration,
+	QuirkNmRequestDelay:          (*Quirk).parseDuration,
+	QuirkNmUsbMaxInterfaces:      (*Quirk).parseUint,
+	QuirkNmUsbSendDelayThreshold: (*Quirk).parseUint,
+	QuirkNmUsbSendDelay:          (*Quirk).parseDuration,
+	QuirkNmZlpRecvHack:           (*Quirk).parseBool,
+	QuirkNmZlpSend:               (*Quirk).parseBool,
 }
 
 // quirkDefaultStrings contains default values for quirks, in
 // a string form.
 var quirkDefaultStrings = map[string]string{
-	QuirkNmBlacklist:         "false",
-	QuirkNmBuggyIppResponses: "reject",
-	QuirkNmDisableFax:        "false",
-	QuirkNmIgnoreIppStatus:   "false",
-	QuirkNmInitDelay:         "0",
-	QuirkNmInitRetryPartial:  "false",
-	QuirkNmInitReset:         "none",
-	QuirkNmInitTimeout:       DevInitTimeout.String(),
-	QuirkNmRequestDelay:      "0",
-	QuirkNmUsbMaxInterfaces:  "0",
-	QuirkNmUsbSendDelay:      "0",
-	QuirkNmZlpRecvHack:       "false",
-	QuirkNmZlpSend:           "false",
+	QuirkNmBlacklist:             "false",
+	QuirkNmBuggyIppResponses:     "reject",
+	QuirkNmDisableFax:            "false",
+	QuirkNmIgnoreIppStatus:       "false",
+	QuirkNmInitDelay:             "0",
+	QuirkNmInitRetryPartial:      "false",
+	QuirkNmInitReset:             "none",
+	QuirkNmInitTimeout:           DevInitTimeout.String(),
+	QuirkNmRequestDelay:          "0",
+	QuirkNmUsbMaxInterfaces:      "0",
+	QuirkNmUsbSendDelayThreshold: "0",
+	QuirkNmUsbSendDelay:          "0",
+	QuirkNmZlpRecvHack:           "false",
+	QuirkNmZlpSend:               "false",
 }
 
 // quirkDefault contains default values for quirks, precompiled.
@@ -362,6 +365,12 @@ func (quirks Quirks) GetUsbMaxInterfaces() uint {
 	return quirks.Get(QuirkNmUsbMaxInterfaces).Parsed.(uint)
 }
 
+// GetUsbSendDelayThreshold returns effective "usb-send-delay-threshold"
+// parameter taking the whole set into consideration.
+func (quirks Quirks) GetUsbSendDelayThreshold() uint {
+	return quirks.Get(QuirkNmUsbSendDelay).Parsed.(uint)
+}
+
 // GetUsbSendDelay returns effective "usb-send-delay" parameter
 // taking the whole set into consideration.
 func (quirks Quirks) GetUsbSendDelay() time.Duration {

usbio_libusb.go

@@ -811,7 +811,10 @@ func (iface *UsbInterface) Send(ctx context.Context,
 
 	// Introduce inter-URB send delay, if configured
 	if delay := iface.quirks.GetUsbSendDelay(); delay != 0 {
-		time.Sleep(delay)
+		threshold := int(iface.quirks.GetUsbSendDelayThreshold())
+		if n > threshold {
+			time.Sleep(delay)
+		}
 	}
 
 	return