blob: use uppercase for macroes, add some functionality

Normalizing macro names to upper case and extending functionality.

3 files changed, 135 insertions, 64 deletions

diff --git a/blob.c b/blob.c
index a25e5e8..377ec62 100644
--- a/blob.c
+++ b/blob.c
@@ -1,6 +1,18 @@
 #include "blob.h"
 
 const blob_t BLOB_NULL = { NULL, 0 };
+static const char *xd = "0123456789abcdefghijklmnopqrstuvwxyz";
+
+static inline int dx(int c)
+{
+	if (likely(c >= '0' && c <= '9'))
+		return c - '0';
+	if (likely(c >= 'a' && c <= 'f'))
+		return c - 'a' + 0xa;
+	if (c >= 'A' && c <= 'F')
+		return c - 'A' + 0xa;
+	return -1;
+}
 
 char *blob_cstr_dup(blob_t b)
 {
@@ -45,7 +57,7 @@ blob_t blob_pushed(blob_t buffer, blob_t left)
 {
 	if (buffer.ptr + buffer.len != left.ptr + left.len)
 		return BLOB_NULL;
-	return blob_dyn(buffer.ptr, left.ptr - buffer.ptr);
+	return BLOB_PTR_LEN(buffer.ptr, left.ptr - buffer.ptr);
 }
 
 void blob_push(blob_t *b, blob_t d)
@@ -59,13 +71,22 @@ void blob_push(blob_t *b, blob_t d)
 	}
 }
 
-void blob_push_int_str(blob_t *b, int val)
+void blob_push_uint(blob_t *to, unsigned int value, int radix)
 {
-	int l;
+	char buf[64];
+	char *ptr = &buf[sizeof(buf)-1];
+
+	if (value == 0) {
+		blob_push(to, BLOB_STR("0"));
+		return;
+	}
+
+	while (value != 0) {
+		*(ptr--) = xd[value % radix];
+		value /= radix;
+	}
 
-	l = snprintf(b->ptr, b->len, "%d", val);
-	b->ptr += l;
-	b->len -= l;
+	blob_push(to, BLOB_PTR_PTR(ptr+1, &buf[sizeof(buf)-1]));
 }
 
 void blob_push_hexdump(blob_t *to, blob_t binary)
@@ -95,7 +116,7 @@ blob_t blob_pull(blob_t *b, int len)
 	blob_t r;
 
 	if (b->len >= len) {
-		r = blob_dyn(b->ptr, len);
+		r = BLOB_PTR_LEN(b->ptr, len);
 		b->ptr += len;
 		b->len -= len;
 		return r;
@@ -125,3 +146,37 @@ int blob_pull_matching(blob_t *b, blob_t e)
 	return 1;
 }
 
+unsigned int blob_pull_uint(blob_t *b, int radix)
+{
+	unsigned int val;
+	int ch;
+
+	val = 0;
+	while (b->len && b->ptr[0] != 0) {
+		ch = dx(b->ptr[0]);
+		if (ch < 0 || ch >= radix)
+			break;
+		val *= radix;
+		val += ch;
+
+		b->ptr++;
+		b->len--;
+	}
+
+	return val;
+}
+
+blob_t blob_pull_cspn(blob_t *b, const blob_t reject)
+{
+	blob_t t = *b;
+	int i;
+
+	for (i = 0; i < t.len; i++) {
+		if (memchr(reject.ptr, t.ptr[i], reject.len) != NULL) {
+			*b = BLOB_PTR_LEN(t.ptr + i, t.len - i);
+			return BLOB_PTR_LEN(t.ptr, i);
+		}
+	}
+	*b = BLOB_NULL;
+	return t;
+}
diff --git a/blob.h b/blob.h
index ad242a8..883c053 100644
--- a/blob.h
+++ b/blob.h
@@ -3,16 +3,31 @@
 
 #include <string.h>
 
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+#if defined __GNUC__ && __GNUC__ == 2 && __GNUC_MINOR__ < 96
+#define __builtin_expect(x, expected_value) (x)
+#endif
+
+#ifndef likely
+#define likely(x) __builtin_expect((!!(x)),1)
+#endif
+
+#ifndef unlikely
+#define unlikely(x) __builtin_expect((!!(x)),0)
+#endif
+
 typedef struct blob {
 	char *ptr;
 	unsigned int len;
 } blob_t;
 
-#define blob_dyn(ptr,len)	(blob_t){(void*)(ptr), (len)}
-#define blob_buf(buf)		(blob_t){(void*)(buf), sizeof(buf)}
-#define blob_str(str)		(blob_t){(char*)(str), strlen(str)}
+#define BLOB_PTR_LEN(ptr,len)	(blob_t){(void*)(ptr), (len)}
+#define BLOB_PTR_PTR(beg,end)	BLOB_PTR_LEN((beg),(end)-(beg)+1)
+#define BLOB_BUF(buf)		(blob_t){(void*)(buf), sizeof(buf)}
+#define BLOB_STR(str)		(blob_t){(char*)(str), strlen(str)}
 
-extern const blob_t BLOB_NULL;;
+extern const blob_t BLOB_NULL;
 
 static inline int blob_is_null(blob_t b)
 {
@@ -24,11 +39,12 @@ blob_t blob_dup(blob_t b);
 int blob_cmp(blob_t a, blob_t b);
 blob_t blob_pushed(blob_t buffer, blob_t left);
 void blob_push(blob_t *b, blob_t d);
-void blob_push_int_str(blob_t *b, int val);
+void blob_push_uint(blob_t *to, unsigned int value, int radix);
 void blob_push_hexdump(blob_t *to, blob_t binary);
 blob_t blob_pull(blob_t *b, int len);
 void blob_pull_skip(blob_t *b, int len);
 int blob_pull_matching(blob_t *b, blob_t e);
-
+unsigned int blob_pull_uint(blob_t *b, int radix);
+blob_t blob_pull_cspn(blob_t *b, const blob_t cspn);
 
 #endif
diff --git a/squark-auth.c b/squark-auth.c
index db792e7..d0b3390 100644
--- a/squark-auth.c
+++ b/squark-auth.c
@@ -102,8 +102,8 @@ static int username_format_flags;
 
 /* ----------------------------------------------------------------- */
 
-#define blob_oid(objid)		blob_buf(objid)
-#define blob_oid_dyn(objid,len)	blob_dyn(objid, (len) * sizeof(oid))
+#define BLOB_OID(objid)		BLOB_BUF(objid)
+#define BLOB_OID_DYN(objid,len)	BLOB_PTR_LEN(objid, (len) * sizeof(oid))
 
 static inline void blob_push_oid(blob_t *b, oid objid)
 {
@@ -218,7 +218,7 @@ void blob_push_iana_afn(blob_t *b, sockaddr_any *addr)
 	}
 	blob_push_oid(b, type);
 	blob_push_oid(b, len);
-	blob_push_oid_dump(b, blob_dyn(ptr, len));
+	blob_push_oid_dump(b, BLOB_PTR_LEN(ptr, len));
 }
 
 sockaddr_any *blob_pull_iana_afn(blob_t *b, sockaddr_any *addr)
@@ -237,7 +237,7 @@ sockaddr_any *blob_pull_iana_afn(blob_t *b, sockaddr_any *addr)
 		blob_pull_skip(b, len);
 		return NULL;
 	}
-	blob_pull_oid_dump(b, blob_dyn(ptr, len));
+	blob_pull_oid_dump(b, BLOB_PTR_LEN(ptr, len));
 	return addr;
 }
 
@@ -483,7 +483,7 @@ int resolve_ifName2ifIndex(struct switch_info *si, blob_t ifName)
 			if (vars->type != ASN_OCTET_STR)
 				continue;
 
-			if (blob_cmp(ifName, blob_dyn(vars->val.string, vars->val_len)) != 0)
+			if (blob_cmp(ifName, BLOB_PTR_LEN(vars->val.string, vars->val_len)) != 0)
 				continue;
 
 			rc = vars->name[vars->name_length - 1];
@@ -550,31 +550,31 @@ static void blob_push_formatted_username(
 	struct switch_info *si = auth->current_switch;
 
 	while ((p = strchr(p, '%')) != NULL) {
-		blob_push(b, blob_dyn(o, p - o));
+		blob_push(b, BLOB_PTR_LEN(o, p - o));
 		switch (p[1]) {
 		case 'I':
-			blob_push(b, blob_str(addr_print(&auth->addr)));
+			blob_push(b, BLOB_STR(addr_print(&auth->addr)));
 			break;
 		case 'M':
-			blob_push_hexdump(b, blob_buf(auth->mac));
+			blob_push_hexdump(b, BLOB_BUF(auth->mac));
 			break;
 		case 'N':
-			blob_push(b, blob_str(si->system_name));
+			blob_push(b, BLOB_STR(si->system_name));
 			break;
 		case 'L':
-			blob_push(b, blob_str(si->system_location));
+			blob_push(b, BLOB_STR(si->system_location));
 			break;
 		case 'i':
-			blob_push_int_str(b, auth->local_port);
+			blob_push_uint(b, auth->local_port, 10);
 			break;
 		case 'n':
-			blob_push(b, blob_str(auth->port_name));
+			blob_push(b, BLOB_STR(auth->port_name));
 			break;
 		case 'd':
-			blob_push(b, blob_str(auth->port_descr));
+			blob_push(b, BLOB_STR(auth->port_descr));
 			break;
 		case 'w':
-			blob_push(b, blob_str(auth->webauth_name));
+			blob_push(b, BLOB_STR(auth->webauth_name));
 			break;
 		default:
 			o = p;
@@ -584,7 +584,7 @@ static void blob_push_formatted_username(
 		p += 2;
 		o = p;
 	}
-	blob_push(b, blob_str(o));
+	blob_push(b, BLOB_STR(o));
 }
 
 static int auth_ok(struct auth_context *auth)
@@ -595,17 +595,17 @@ static int auth_ok(struct auth_context *auth)
 static void auth_completed(struct auth_context *auth)
 {
 	char tmp[256];
-	blob_t b = blob_buf(tmp);
+	blob_t b = BLOB_BUF(tmp);
 
-	blob_push(&b, blob_str(auth->token));
+	blob_push(&b, BLOB_STR(auth->token));
 	if (auth_ok(auth)) {
-		blob_push(&b, blob_str(" OK user="));
+		blob_push(&b, BLOB_STR(" OK user="));
 		blob_push_formatted_username(&b, username_format, auth);
-		blob_push(&b, blob_dyn("\n", 1));
+		blob_push(&b, BLOB_PTR_LEN("\n", 1));
 	} else {
-		blob_push(&b, blob_str(" ERR\n"));
+		blob_push(&b, BLOB_STR(" ERR\n"));
 	}
-	b = blob_pushed(blob_buf(tmp), b);
+	b = blob_pushed(BLOB_BUF(tmp), b);
 	write(STDOUT_FILENO, b.ptr, b.len);
 
 	auth_free(auth);
@@ -638,7 +638,7 @@ static blob_t var_parse_type(netsnmp_variable_list **varptr, int asn_tag)
 	if (var->type != asn_tag)
 		return BLOB_NULL;
 
-	return blob_dyn(var->val.string, var->val_len);
+	return BLOB_PTR_LEN(var->val.string, var->val_len);
 }
 
 static int auth_handle_portinfo_reply(int oper, netsnmp_session *s, int reqid, netsnmp_pdu *resp, void *data)
@@ -682,25 +682,25 @@ static void auth_query_port_info(struct auth_context *auth)
 
 	pdu = snmp_pdu_create(SNMP_MSG_GET);
 	if (username_format_flags & FORMAT_PORT_NAME) {
-		query = blob_oid(query_oids);
-		blob_push(&query, blob_oid(IF_MIB_ifName));
+		query = BLOB_OID(query_oids);
+		blob_push(&query, BLOB_OID(IF_MIB_ifName));
 		blob_push_oid(&query, auth->local_port);
-		query = blob_pushed(blob_oid(query_oids), query);
+		query = blob_pushed(BLOB_OID(query_oids), query);
 		snmp_add_null_var(pdu, oid_blob(query));
 	}
 	if (username_format_flags & FORMAT_PORT_DESCR) {
-		query = blob_oid(query_oids);
-		blob_push(&query, blob_oid(IF_MIB_ifDescr));
+		query = BLOB_OID(query_oids);
+		blob_push(&query, BLOB_OID(IF_MIB_ifDescr));
 		blob_push_oid(&query, auth->local_port);
-		query = blob_pushed(blob_oid(query_oids), query);
+		query = blob_pushed(BLOB_OID(query_oids), query);
 		snmp_add_null_var(pdu, oid_blob(query));
 	}
 	if (username_format_flags & FORMAT_PORT_WEBAUTH) {
-		query = blob_oid(query_oids);
-		blob_push(&query, blob_oid(HP_hpicfUsrAuthWebAuthSessionName));
+		query = BLOB_OID(query_oids);
+		blob_push(&query, BLOB_OID(HP_hpicfUsrAuthWebAuthSessionName));
 		blob_push_oid(&query, auth->local_port);
-		blob_push_oid_dump(&query, blob_buf(auth->mac));
-		query = blob_pushed(blob_oid(query_oids), query);
+		blob_push_oid_dump(&query, BLOB_BUF(auth->mac));
+		query = blob_pushed(BLOB_OID(query_oids), query);
 		snmp_add_null_var(pdu, oid_blob(query));
 	}
 	auth_talk_snmp(auth, si->session, pdu, auth_handle_portinfo_reply);
@@ -725,8 +725,8 @@ static int auth_handle_lldp_reply(int oper, netsnmp_session *s, int reqid, netsn
 		if (var->type != ASN_INTEGER)
 			continue;
 		/* INDEX: TimeFilter, Port, Idx, Family, Addr */
-		res = blob_oid_dyn(var->name, var->name_length);
-		if (blob_pull_matching(&res, blob_oid(LLDP_lldpRemManAddrIfSubtype)) &&
+		res = BLOB_OID_DYN(var->name, var->name_length);
+		if (blob_pull_matching(&res, BLOB_OID(LLDP_lldpRemManAddrIfSubtype)) &&
 		    blob_pull_oid(&res) == 0 &&
 		    blob_pull_oid(&res) == auth->lldp_port[i]) {
 			/* We have mathing LLDP neighbor */
@@ -743,8 +743,8 @@ static int auth_handle_lldp_reply(int oper, netsnmp_session *s, int reqid, netsn
 		if (var->type != ASN_INTEGER)
 			break;
 		/* print_variable(var->name, var->name_length, var); */
-		res = blob_oid_dyn(var->name, var->name_length);
-		if (!blob_pull_matching(&res, blob_oid(IF_MIB_ifStackStatus)))
+		res = BLOB_OID_DYN(var->name, var->name_length);
+		if (!blob_pull_matching(&res, BLOB_OID(IF_MIB_ifStackStatus)))
 			break;
 		if (blob_pull_oid(&res) != auth->local_port)
 			break;
@@ -790,21 +790,21 @@ static void auth_query_lldp(struct auth_context *auth, int root_query)
 	for (i = 0; i < auth->num_lldp_ports; i++) {
 		/* Query LLDP neighbor. lldpRemManAddrTable is INDEXed with
 		 * [TimeFilter, LocalPort, Index, AddrSubType, Addr] */
-		query = blob_oid(query_oids);
-		blob_push(&query, blob_oid(LLDP_lldpRemManAddrIfSubtype));
+		query = BLOB_OID(query_oids);
+		blob_push(&query, BLOB_OID(LLDP_lldpRemManAddrIfSubtype));
 		blob_push_oid(&query, 0);
 		blob_push_oid(&query, auth->lldp_port[i]);
-		query = blob_pushed(blob_oid(query_oids), query);
+		query = blob_pushed(BLOB_OID(query_oids), query);
 		snmp_add_null_var(pdu, oid_blob(query));
 	}
 
 	if (root_query) {
 		/* Query interface stacking in case this is aggregated trunk:
 		 * IF-MIB::ifStackStatus.<ifUpperIndex>.<ifLowerIndex> */
-		query = blob_oid(query_oids);
-		blob_push(&query, blob_oid(IF_MIB_ifStackStatus));
+		query = BLOB_OID(query_oids);
+		blob_push(&query, BLOB_OID(IF_MIB_ifStackStatus));
 		blob_push_oid(&query, auth->local_port);
-		query = blob_pushed(blob_oid(query_oids), query);
+		query = blob_pushed(BLOB_OID(query_oids), query);
 		snmp_add_null_var(pdu, oid_blob(query));
 	}
 
@@ -868,12 +868,12 @@ static void auth_query_fib(struct auth_context *auth)
 	/* FIXME: Implement Q-BRIDGE-MIB query too. */
 
 	/* BRIDGE-MIB::dot1dTpFdbPort.<MAC> = INTEGER: port */
-	query = blob_oid(query_oids);
-	blob_push(&query, blob_oid(BRIDGE_MIB_dot1dTpFdbPort));
+	query = BLOB_OID(query_oids);
+	blob_push(&query, BLOB_OID(BRIDGE_MIB_dot1dTpFdbPort));
 	if (si->flags & SWITCHF_BRIDGE_MIB_HAS_VLAN)
 		blob_push_oid(&query, l2_vlan_ndx);
-	blob_push_oid_dump(&query, blob_buf(auth->mac));
-	query = blob_pushed(blob_oid(query_oids), query);
+	blob_push_oid_dump(&query, BLOB_BUF(auth->mac));
+	query = blob_pushed(BLOB_OID(query_oids), query);
 	snmp_add_null_var(pdu, oid_blob(query));
 
 	auth_talk_snmp(auth, si->session, pdu, auth_handle_fib_reply);
@@ -901,7 +901,7 @@ static int auth_handle_switch_info_reply(int oper, netsnmp_session *s, int reqid
 	if (si->system_location)
 		si->info_available |= FORMAT_SWITCH_LOCATION;
 	b = si->system_oid;
-	if (blob_pull_matching(&b, blob_oid(HP_ICF_OID_hpEtherSwitch))) {
+	if (blob_pull_matching(&b, BLOB_OID(HP_ICF_OID_hpEtherSwitch))) {
 		/* Hewlett-Packard ProCurve Switches */
 		switch (blob_pull_oid(&b)) {
 		case 104: /* 1810G-24 */
@@ -976,11 +976,11 @@ void start_authentication(const char *token, const char *ip)
 	 *  = STRING: 01:12:34:56:78:9a */
 	pdu = snmp_pdu_create(SNMP_MSG_GET);
 
-	query = blob_oid(query_oids);
-	blob_push(&query, blob_oid(IP_MIB_ipNetToPhysicalPhysAddress));
+	query = BLOB_OID(query_oids);
+	blob_push(&query, BLOB_OID(IP_MIB_ipNetToPhysicalPhysAddress));
 	blob_push_oid(&query, l3_if_ndx);
 	blob_push_iana_afn(&query, &auth->addr);
-	query = blob_pushed(blob_oid(query_oids), query);
+	query = blob_pushed(BLOB_OID(query_oids), query);
 	snmp_add_null_var(pdu, oid_blob(query));
 
 	auth_talk_snmp(auth, l3_root_dev->session, pdu, auth_handle_arp_reply);
@@ -1080,7 +1080,7 @@ int main(int argc, char **argv)
 		l2_root = l3_root;
 
 	l3_root_dev = get_switch(addr_parse(l3_root, &addr));
-	l3_if_ndx   = resolve_ifName2ifIndex(l3_root_dev, blob_str((char *) l3_ifname));
+	l3_if_ndx   = resolve_ifName2ifIndex(l3_root_dev, BLOB_STR((char *) l3_ifname));
 	l2_root_dev = get_switch(addr_parse(l2_root, &addr));
 	l2_vlan_ndx = atoi(l2_vlan);
 	username_format_flags = parse_format(username_format);