libink: 64-bit integer marshalling

Device seqnums are 64-bit; the writer and reader stopped at u32.
Adds t/x/d to the skip path so a{sv} consumers tolerate them.

Signed-off-by: Joachim Wiberg <troglobit@gmail.com>

libink/dispatch.c

@@ -287,6 +287,7 @@ int link_call_reply_error(link_call_t *call, const char *name, const char *messa
 int link_call_read_byte  (link_call_t *c, uint8_t *o)        { return __r_byte  (&c->read_cursor, o); }
 int link_call_read_bool  (link_call_t *c, int *o)            { return __r_bool  (&c->read_cursor, o); }
 int link_call_read_u32   (link_call_t *c, uint32_t *o)       { return __r_u32   (&c->read_cursor, o); }
+int link_call_read_u64   (link_call_t *c, uint64_t *o)       { return __r_u64   (&c->read_cursor, o); }
 int link_call_read_string(link_call_t *c, const char **o)    { return __r_string(&c->read_cursor, o); }
 int link_call_read_path  (link_call_t *c, const char **o)    { return __r_path  (&c->read_cursor, o); }
 
@@ -298,6 +299,7 @@ ssize_t link_writer_finish(link_writer_t *w)                           { return
 void link_w_byte    (link_writer_t *w, uint8_t v)        { __w_byte(w, v); }
 void link_w_bool    (link_writer_t *w, int v)            { __w_bool(w, v); }
 void link_w_u32     (link_writer_t *w, uint32_t v)       { __w_u32(w, v);  }
+void link_w_u64     (link_writer_t *w, uint64_t v)       { __w_u64(w, v);  }
 void link_w_string  (link_writer_t *w, const char *s)    { __w_string(w, s); }
 void link_w_path    (link_writer_t *w, const char *s)    { __w_path(w, s);   }
 void link_w_variant_string(link_writer_t *w, const char *s) { __w_variant_string(w, s); }
@@ -312,6 +314,7 @@ void link_reader_init(link_reader_t *r, const uint8_t *body, size_t len) { __r_i
 int  link_r_byte  (link_reader_t *r, uint8_t  *o)     { return __r_byte  (r, o); }
 int  link_r_bool  (link_reader_t *r, int      *o)     { return __r_bool  (r, o); }
 int  link_r_u32   (link_reader_t *r, uint32_t *o)     { return __r_u32   (r, o); }
+int  link_r_u64   (link_reader_t *r, uint64_t *o)     { return __r_u64   (r, o); }
 int  link_r_string(link_reader_t *r, const char **o)  { return __r_string(r, o); }
 int  link_r_path  (link_reader_t *r, const char **o)  { return __r_path  (r, o); }
 int  link_r_variant_begin (link_reader_t *r, char *type)     { return __r_variant_begin(r, type); }

libink/link.h

@@ -293,6 +293,7 @@ uid_t       link_call_uid      (const link_call_t *call);
 int link_call_read_byte  (link_call_t *call, uint8_t  *out);
 int link_call_read_bool  (link_call_t *call, int      *out);
 int link_call_read_u32   (link_call_t *call, uint32_t *out);
+int link_call_read_u64   (link_call_t *call, uint64_t *out);
 int link_call_read_string(link_call_t *call, const char **out);  /* "s" */
 int link_call_read_path  (link_call_t *call, const char **out);  /* "o" */
 
@@ -434,6 +435,7 @@ ssize_t link_writer_finish(link_writer_t *w);
 void link_w_byte    (link_writer_t *w, uint8_t v);
 void link_w_bool    (link_writer_t *w, int v);
 void link_w_u32     (link_writer_t *w, uint32_t v);
+void link_w_u64     (link_writer_t *w, uint64_t v);      /* "t" */
 void link_w_string  (link_writer_t *w, const char *s);  /* "s" */
 void link_w_path    (link_writer_t *w, const char *s);  /* "o" */
 void link_w_variant_string(link_writer_t *w, const char *s); /* "v" containing "s" */
@@ -451,6 +453,7 @@ void   link_reader_init(link_reader_t *r, const uint8_t *body, size_t len);
 int    link_r_byte    (link_reader_t *r, uint8_t  *out);
 int    link_r_bool    (link_reader_t *r, int      *out);
 int    link_r_u32     (link_reader_t *r, uint32_t *out);
+int    link_r_u64     (link_reader_t *r, uint64_t *out);
 int    link_r_string  (link_reader_t *r, const char **out);  /* "s" */
 int    link_r_path    (link_reader_t *r, const char **out);  /* "o" */
 int    link_r_variant_begin (link_reader_t *r, char *type);       /* sig header, cursor at value */

libink/marshal.c

@@ -79,6 +79,14 @@ void __w_u32(struct link_writer *w, uint32_t v)
 	put_u32(w, v);
 }
 
+void __w_u64(struct link_writer *w, uint64_t v)
+{
+	if (reserve(w, 8, 8) < 0)
+		return;
+	put_u32(w, (uint32_t)(v & 0xffffffffu));
+	put_u32(w, (uint32_t)(v >> 32));
+}
+
 static void write_lenprefixed(struct link_writer *w, const char *s, int onebyte_len)
 {
 	size_t len = s ? strlen(s) : 0;
@@ -230,6 +238,18 @@ int __r_u32(struct link_reader *r, uint32_t *out)
 	return 0;
 }
 
+int __r_u64(struct link_reader *r, uint64_t *out)
+{
+	if (r_skip_align(r, 8) < 0 || r->off + 8 > r->cap) {
+		r->err = 1;
+		return -1;
+	}
+	*out = (uint64_t)rd_u32(r->base + r->off)
+	     | ((uint64_t)rd_u32(r->base + r->off + 4) << 32);
+	r->off += 8;
+	return 0;
+}
+
 int __r_bool(struct link_reader *r, int *out)
 {
 	uint32_t v;
@@ -327,6 +347,13 @@ int __r_skip_basic(struct link_reader *r, char type)
 	case 'u':
 	case 'i':
 		return __r_u32(r, &u);
+	case 't':
+	case 'x':
+	case 'd': {
+		uint64_t t;
+
+		return __r_u64(r, &t);
+	}
 	case 'y':
 		return __r_byte(r, &y);
 	default:
@@ -396,6 +423,9 @@ ssize_t __marshal_va(uint8_t *body, size_t cap, const char *sig, va_list ap)
 		case 'u':
 			__w_u32(&w, va_arg(ap, uint32_t));
 			break;
+		case 't':
+			__w_u64(&w, va_arg(ap, uint64_t));
+			break;
 		case 's':
 			__w_string(&w, va_arg(ap, const char *));
 			break;

libink/marshal.h

@@ -21,6 +21,7 @@ ssize_t __w_finish(struct link_writer *w);
 
 void __w_byte    (struct link_writer *w, uint8_t v);
 void __w_bool    (struct link_writer *w, int v);
+void __w_u64   (struct link_writer *w, uint64_t v);
 void __w_u32     (struct link_writer *w, uint32_t v);
 void __w_string  (struct link_writer *w, const char *s);  /* "s" */
 void __w_path    (struct link_writer *w, const char *s);  /* "o" */
@@ -44,6 +45,7 @@ void __r_init  (struct link_reader *r, const uint8_t *body, size_t len);
 int  __r_byte  (struct link_reader *r, uint8_t *out);
 int  __r_bool  (struct link_reader *r, int      *out);
 int  __r_u32   (struct link_reader *r, uint32_t *out);
+int  __r_u64   (struct link_reader *r, uint64_t *out);
 int  __r_string(struct link_reader *r, const char **out);  /* "s" */
 int  __r_path  (struct link_reader *r, const char **out);  /* "o" */
 int  __r_variant_begin (struct link_reader *r, char *type);       /* sig header, cursor at value */