Make bufchain_prefix return a ptrlen.

Now that all the call sites are expecting a size_t instead of an int
length field, it's no longer particularly difficult to make it
actually return the pointer,length pair in the form of a ptrlen.

It would be nice to say that simplifies call sites because those
ptrlens can all be passed straight along to other ptrlen-consuming
functions. Actually almost none of the call sites are like that _yet_,
but this makes it possible to move them in that direction in future
(as part of my general aim to migrate ptrlen-wards as much as I can).
But also it's just nicer to keep the pointer and length together in
one variable, and not have to declare them both in advance with two
extra lines of boilerplate.

Author: sgtatham

logging.c

@@ -137,11 +137,9 @@ static void logfopen_callback(void *vctx, int mode)
      */
     assert(ctx->state != L_OPENING);   /* make _sure_ it won't be requeued */
     while (bufchain_size(&ctx->queue)) {
-	void *data;
-	size_t len;
-	bufchain_prefix(&ctx->queue, &data, &len);
-	logwrite(ctx, data, len);
-	bufchain_consume(&ctx->queue, len);
+        ptrlen data = bufchain_prefix(&ctx->queue);
+	logwrite(ctx, data.ptr, data.len);
+	bufchain_consume(&ctx->queue, data.len);
     }
     logflush(ctx);
 }

misc.h

@@ -105,7 +105,7 @@ void bufchain_init(bufchain *ch);
 void bufchain_clear(bufchain *ch);
 size_t bufchain_size(bufchain *ch);
 void bufchain_add(bufchain *ch, const void *data, size_t len);
-void bufchain_prefix(bufchain *ch, void **data, size_t *len);
+ptrlen bufchain_prefix(bufchain *ch);
 void bufchain_consume(bufchain *ch, size_t len);
 void bufchain_fetch(bufchain *ch, void *data, size_t len);
 void bufchain_fetch_consume(bufchain *ch, void *data, size_t len);

noprint.c

@@ -16,7 +16,7 @@ printer_job *printer_start_job(char *printer)
     return NULL;
 }
 
-void printer_job_data(printer_job *pj, void *data, int len)
+void printer_job_data(printer_job *pj, void *data, size_t len)
 {
 }
 

proxy.c

@@ -24,8 +24,7 @@
  */
 void proxy_activate (ProxySocket *p)
 {
-    void *data;
-    size_t len, output_before, output_after;
+    size_t output_before, output_after;
 
     p->state = PROXY_STATE_ACTIVE;
 
@@ -42,16 +41,16 @@ void proxy_activate (ProxySocket *p)
 
     /* send buffered OOB writes */
     while (bufchain_size(&p->pending_oob_output_data) > 0) {
-	bufchain_prefix(&p->pending_oob_output_data, &data, &len);
-	output_after += sk_write_oob(p->sub_socket, data, len);
-	bufchain_consume(&p->pending_oob_output_data, len);
+        ptrlen data = bufchain_prefix(&p->pending_oob_output_data);
+	output_after += sk_write_oob(p->sub_socket, data.ptr, data.len);
+	bufchain_consume(&p->pending_oob_output_data, data.len);
     }
 
     /* send buffered normal writes */
     while (bufchain_size(&p->pending_output_data) > 0) {
-	bufchain_prefix(&p->pending_output_data, &data, &len);
-	output_after += sk_write(p->sub_socket, data, len);
-	bufchain_consume(&p->pending_output_data, len);
+	ptrlen data = bufchain_prefix(&p->pending_output_data);
+	output_after += sk_write(p->sub_socket, data.ptr, data.len);
+	bufchain_consume(&p->pending_output_data, data.len);
     }
 
     /* if we managed to send any data, let the higher levels know. */
@@ -159,15 +158,13 @@ static void sk_proxy_set_frozen (Socket *s, bool is_frozen)
 	 * so we have to check each time.
 	 */
         while (!ps->freeze && bufchain_size(&ps->pending_input_data) > 0) {
-	    void *data;
 	    char databuf[512];
-	    size_t len;
-	    bufchain_prefix(&ps->pending_input_data, &data, &len);
-	    if (len > lenof(databuf))
-		len = lenof(databuf);
-	    memcpy(databuf, data, len);
-	    bufchain_consume(&ps->pending_input_data, len);
-	    plug_receive(ps->plug, 0, databuf, len);
+	    ptrlen data = bufchain_prefix(&ps->pending_input_data);
+	    if (data.len > lenof(databuf))
+		data.len = lenof(databuf);
+	    memcpy(databuf, data.ptr, data.len);
+	    bufchain_consume(&ps->pending_input_data, data.len);
+	    plug_receive(ps->plug, 0, databuf, data.len);
 	}
 
 	/* if we're still frozen, we'll have to wait for another

putty.h

@@ -1841,7 +1841,7 @@ printer_enum *printer_start_enum(int *nprinters);
 char *printer_get_name(printer_enum *, int);
 void printer_finish_enum(printer_enum *);
 printer_job *printer_start_job(char *printer);
-void printer_job_data(printer_job *, void *, int);
+void printer_job_data(printer_job *, const void *, size_t);
 void printer_finish_job(printer_job *);
 
 /*

rlogin.c

@@ -287,10 +287,8 @@ static size_t rlogin_send(Backend *be, const char *buf, size_t len)
 
     if (!rlogin->prompt) {
         while (bufchain_size(&bc) > 0) {
-            void *data;
-            size_t len;
-            bufchain_prefix(&bc, &data, &len);
-            rlogin->bufsize = sk_write(rlogin->s, data, len);
+            ptrlen data = bufchain_prefix(&bc);
+            rlogin->bufsize = sk_write(rlogin->s, data.ptr, data.len);
             bufchain_consume(&bc, len);
         }
     }

scpserver.c

@@ -1077,17 +1077,13 @@ static void scp_sink_coroutine(ScpSink *scp)
             if (scp->input_eof)
                 goto done;
 
-            void *vdata;
-            size_t len;
-            const char *cdata, *newline;
-
-            bufchain_prefix(&scp->data, &vdata, &len);
-            cdata = vdata;
-            newline = memchr(cdata, '\012', len);
+            ptrlen data = bufchain_prefix(&scp->data);
+            const char *cdata = data.ptr;
+            const char *newline = memchr(cdata, '\012', data.len);
             if (newline)
-                len = (int)(newline+1 - cdata);
-            put_data(scp->command, cdata, len);
-            bufchain_consume(&scp->data, len);
+                data.len = (int)(newline+1 - cdata);
+            put_data(scp->command, cdata, data.len);
+            bufchain_consume(&scp->data, data.len);
 
             if (newline)
                 break;
@@ -1179,8 +1175,7 @@ static void scp_sink_coroutine(ScpSink *scp)
                 sshfwd_write(scp->sc, "\0", 1);
                 scp->file_offset = 0;
                 while (scp->file_offset < scp->file_size) {
-                    void *vdata;
-                    size_t len;
+                    ptrlen data;
                     uint64_t this_len, remaining;
 
                     crMaybeWaitUntilV(
@@ -1191,14 +1186,14 @@ static void scp_sink_coroutine(ScpSink *scp)
                         goto done;
                     }
 
-                    bufchain_prefix(&scp->data, &vdata, &len);
-                    this_len = len;
+                    data = bufchain_prefix(&scp->data);
+                    this_len = data.len;
                     remaining = scp->file_size - scp->file_offset;
                     if (this_len > remaining)
                         this_len = remaining;
                     sftpsrv_write(scp->sf, &scp->reply.srb,
                                   scp->reply.handle, scp->file_offset,
-                                  make_ptrlen(vdata, this_len));
+                                  make_ptrlen(data.ptr, this_len));
                     if (scp->reply.err) {
                         scp->errmsg = dupprintf(
                             "'%.*s': unable to write to file: %s",

ssh.c

@@ -348,17 +348,16 @@ static void ssh_bpp_output_raw_data_callback(void *vctx)
         return;
 
     while (bufchain_size(&ssh->out_raw) > 0) {
-        void *data;
-        size_t len, backlog;
+        size_t backlog;
 
-        bufchain_prefix(&ssh->out_raw, &data, &len);
+        ptrlen data = bufchain_prefix(&ssh->out_raw);
 
         if (ssh->logctx)
-            log_packet(ssh->logctx, PKT_OUTGOING, -1, NULL, data, len,
+            log_packet(ssh->logctx, PKT_OUTGOING, -1, NULL, data.ptr, data.len,
                        0, NULL, NULL, 0, NULL);
-        backlog = sk_write(ssh->s, data, len);
+        backlog = sk_write(ssh->s, data.ptr, data.len);
 
-        bufchain_consume(&ssh->out_raw, len);
+        bufchain_consume(&ssh->out_raw, data.len);
 
         if (backlog > SSH_MAX_BACKLOG) {
             ssh_throttle_all(ssh, true, backlog);

ssh1connection.c

@@ -780,13 +780,11 @@ static void ssh1_connection_got_user_input(PacketProtocolLayer *ppl)
         /*
          * Add user input to the main channel's buffer.
          */
-        void *data;
-        size_t len;
-        bufchain_prefix(s->ppl.user_input, &data, &len);
-        if (len > 512)
-            len = 512;
-        sshfwd_write(&s->mainchan_sc, data, len);
-        bufchain_consume(s->ppl.user_input, len);
+        ptrlen data = bufchain_prefix(s->ppl.user_input);
+        if (data.len > 512)
+            data.len = 512;
+        sshfwd_write(&s->mainchan_sc, data.ptr, data.len);
+        bufchain_consume(s->ppl.user_input, data.len);
     }
 }
 

ssh2connection.c

@@ -1064,16 +1064,14 @@ static size_t ssh2_try_send(struct ssh2_channel *c)
     while (c->remwindow > 0 &&
            (bufchain_size(&c->outbuffer) > 0 ||
             bufchain_size(&c->errbuffer) > 0)) {
-	size_t len;
-	void *data;
         bufchain *buf = (bufchain_size(&c->errbuffer) > 0 ?
                          &c->errbuffer : &c->outbuffer);
 
-	bufchain_prefix(buf, &data, &len);
-	if (len > c->remwindow)
-	    len = c->remwindow;
-	if (len > c->remmaxpkt)
-	    len = c->remmaxpkt;
+	ptrlen data = bufchain_prefix(buf);
+	if (data.len > c->remwindow)
+	    data.len = c->remwindow;
+	if (data.len > c->remmaxpkt)
+	    data.len = c->remmaxpkt;
         if (buf == &c->errbuffer) {
             pktout = ssh_bpp_new_pktout(
                 s->ppl.bpp, SSH2_MSG_CHANNEL_EXTENDED_DATA);
@@ -1083,10 +1081,10 @@ static size_t ssh2_try_send(struct ssh2_channel *c)
             pktout = ssh_bpp_new_pktout(s->ppl.bpp, SSH2_MSG_CHANNEL_DATA);
             put_uint32(pktout, c->remoteid);
         }
-        put_string(pktout, data, len);
+        put_stringpl(pktout, data);
         pq_push(s->ppl.out_pq, pktout);
-	bufchain_consume(buf, len);
-	c->remwindow -= len;
+	bufchain_consume(buf, data.len);
+	c->remwindow -= data.len;
     }
 
     /*
@@ -1670,11 +1668,9 @@ static void ssh2_connection_got_user_input(PacketProtocolLayer *ppl)
         /*
          * Add user input to the main channel's buffer.
          */
-        void *data;
-        size_t len;
-        bufchain_prefix(s->ppl.user_input, &data, &len);
-        sshfwd_write(s->mainchan_sc, data, len);
-        bufchain_consume(s->ppl.user_input, len);
+        ptrlen data = bufchain_prefix(s->ppl.user_input);
+        sshfwd_write(s->mainchan_sc, data.ptr, data.len);
+        bufchain_consume(s->ppl.user_input, data.len);
     }
 }