* hbytes overwrite VAR START VALUE
* hbytes trimleft VAR removes any leading 0 octets
* hbytes repeat VALUE COUNT => COUNT copies of VALUE
+ * hbytes zeroes COUNT => COUNT zero bytes
+ * hbytes random COUNT => COUNT random bytes
+ * hbytes xor VAR VALUE $VAR (+)= VALUE
*
* hbytes ushort2h LONG => LONG must be <2^16, returns as hex
* hbytes h2ushort HEX => |HEX| must be 2 bytes, returns as ulong
* +1 A is B plus a nonempty suffix (ie, A has B as a prefix)
* +2 A is lexically later than B and does not have B as a prefix
*
- * hbytes pkcs5 pa|ua VAR ALG => worked? (always 1 for p)
- * hbytes pkcs5 pn|un VAR BLOCKSIZE => worked? (always 1 for p)
+ * hbytes pad pa|ua VAR ALG METH [METHARGS] => worked? (always 1 for p)
+ * hbytes pad pn|un VAR BS METH [METHARGS] => worked? (always 1 for p)
+ * hbytes pad pa|pn VAR ALG|BS pkcs5 => 1
+ * hbytes pad ua|un VAR ALG|BS pkcs5 => worked?
+ * hbytes pad pa|pn VAR ALG|BS rfc2406 NXTHDR => 1
+ * hbytes pad ua|un VAR ALG|BS rfc2406 NXTHDRVAR => worked?
+ *
* hbytes blockcipher d|e VAR ALG KEY MODE [IV] => IV
* hbytes blockcipher mac MSG ALG KEY MODE IV => final block
+ * hbytes blockcipher prop PROPERTY ALG => property value
*
* hbytes hash ALG MESSAGE => hash
* hbytes hmac ALG MESSAGE KEY [MACLENGTH] => mac
+ * hbytes hash-prop PROPERTY ALG => property value
*
* ulong ul2int ULONG => INT can fail if >INT_MAX
* ulong int2ul INT => ULONG can fail if <0
* ulong mask A B => A & B
* ulong add A B => A + B (mod 2^32)
* ulong subtract A B => A - B (mod 2^32)
- * ulong compare A B => 0/-1/1
+ * ulong compare A B => 0 -1 (A<B) +1 (A>B)
* ulong shift l|r ULONG BITS fails if BITS >32
*
* ulong ul2bitfields VALUE [SIZE TYPE [TYPE-ARG...] ...] => 0/1
* uint VARNAME/VALUE (VARNAME if ul2bitfields;
* ulong VARNAME/VALUE VALUE if bitfields2ul)
*
+ * Mask maps:
+ *
+ * A maskmap is a slightly efficient mapping from addresses to
+ * arbitrary data values. An address is a number of octets expressed
+ * as an hbytes. All the addresses covered by the same maskmap
+ * should have the same length (even though constructing the maskmap
+ * does not involve specifying that length).
+ *
+ * hbytes mask-map lookup MAP-VAR ADDRESS [DEFAULT] => DATA
+ * Error on missing default or if any prefix longer than ADDRESS.
+ *
+ * hbytes mask-map amend MAP-VAR PREFIX PREFIX-LENGTH DATA
+ * Sets all of the addresses in PREFIX/PREFIX-LENGTH to the
+ * relevant value.
+ *
+ * Representation:
+ * A maskmap MAP is [list [list PREFIX PREFIX-LENGTH DATA]].
+ * The list is sorted by ascending PREFIX and entries do not overlap.
+ * Each PREFIX in the map is truncated to the shortest number of
+ * pairs of hex digits which can represent it.
+ *
* Error codes
*
* HBYTES BLOCKCIPHER CRYPTFAIL CRYPT block cipher mode failed somehow (!)
* HBYTES LENGTH OVERRUN block too long
* HBYTES LENGTH RANGE input length or offset is -ve or silly
* HBYTES LENGTH UNDERRUN block too short (or offset too big)
+ * HBYTES LENGTH MISMATCH when blocks must be exactly same length
* HBYTES SYNTAX supposed hex block had wrong syntax
* HBYTES VALUE OVERFLOW value to be conv'd to hex too big/long
+ * HBYTES MASKMAP NOMATCH no addr/mask matches address for lookup
+ * HBYTES MASKMAP UNDERRUN addr value for lookup is too short
+ * HBYTES MASKMAP SYNTAX LLENGTH value for mask-map entry not llength==3
+ * HBYTES MASKMAP SYNTAX UNDERRUN value for mask-map entry hex too short
+ * HBYTES MASKMAP SYNTAX OVERRUN actual mask-map entry hex too short
+ * HBYTES MASKMAP SYNTAX ORDER actual mask-map is disordered
+ * HBYTES MASKMAP SYNTAX EXCLBITS mask-map has 1-bits outside prefix len
* SOCKADDR AFUNIX LENGTH path for AF_UNIX socket too long
* SOCKADDR SYNTAX IPV4 bad IPv4 socket address &/or port
* SOCKADDR SYNTAX OTHER bad socket addr, couldn't tell what kind
* ULONG BITCOUNT UNDERRUN bitfields add up to less than 32
* ULONG VALUE NEGATIVE attempt convert -ve integers to ulong
* ULONG VALUE OVERFLOW converted value does not fit in result
+ * TUNTAP IFNAME LENGTH tun/tap interface name too long
+ * TUNTAP MTU OVERRUN tun/tap mtu limited to 2^16 bytes
*
- * Refs: HMAC: RFC2104
- */
+ * Refs: HMAC: RFC2104 */
#ifndef HBYTES_H
#define HBYTES_H
#include <sys/un.h>
#include <arpa/inet.h>
-#include <tcl.h>
+#include <tcl8.3/tcl.h>
+
+#include <adns.h>
typedef unsigned char Byte;
const struct sockaddr *sockaddr_addr(const SockAddr_Value*);
void sockaddr_free(const SockAddr_Value*);
+/* from scriptinv.c */
+
+typedef struct { /* semi-opaque - read only, and then only where commented */
+ Tcl_Interp *ip; /* valid, non-0 and useable if set */
+ Tcl_Obj *obj; /* non-0 iff set (but only test for 0/non-0) */
+ Tcl_Obj *xargs;
+ int llength;
+} ScriptToInvoke;
+
+void scriptinv_init(ScriptToInvoke *si);
+int scriptinv_set(ScriptToInvoke *si, Tcl_Interp *ip,
+ Tcl_Obj *newscript, Tcl_Obj *xargs);
+void scriptinv_cancel(ScriptToInvoke *si); /* then don't invoke */
+ /* no separate free function - just cancel */
+
+void scriptinv_invoke(ScriptToInvoke *si, int argc, Tcl_Obj *const *argv);
+
+/* from idtable.c */
+
+typedef struct {
+ const char *valprefix, *assockey;
+ void (*destroyitem)(Tcl_Interp *ip, void *val);
+} IdDataSpec;
+
+/* The stored struct must start with a single int, conventionally
+ * named `ix'. When the struct is returned for the first time ix must
+ * be -1; on subsequent occasions it must be >=0. ix will be -1 iff
+ * the struct is registered by the iddatatable machinery. */
+
+extern Tcl_ObjType tabledataid_nearlytype;
+int tabledataid_parse(Tcl_Interp *ip, Tcl_Obj *o, const IdDataSpec *idds);
+void tabledataid_disposing(Tcl_Interp *ip, void *val, const IdDataSpec *idds);
+ /* call this when you destroy the struct, to remove its name;
+ * _disposing is idempotent */
+
+/* from adns.c */
+
+typedef struct {
+ const char *name;
+ adns_rrtype number;
+} AdnsTclRRTypeInfo;
+
+extern const IdDataSpec adnstcl_queries, adnstcl_resolvers;
+
/* from dgram.c */
-extern Tcl_ObjType dgramsockid_type;
-typedef struct DgramSocket *DgramSockID;
+extern const IdDataSpec dgram_socks;
+int newfdposixerr(Tcl_Interp *ip, int fd, const char *m);
+
+/* from tuntap.c */
+
+extern const IdDataSpec tuntap_socks;
/* from hook.c */
/* from parse.c */
typedef struct {
- HBytes_Value *hb;
Tcl_Obj *obj, *var;
int copied;
+} Something_Var;
+
+void init_somethingv(Something_Var *sth);
+void fini_somethingv(Tcl_Interp *ip, int rc, Something_Var *sth);
+int pat_somethingv(Tcl_Interp *ip, Tcl_Obj *var,
+ Something_Var *sth, Tcl_ObjType *type);
+
+typedef struct {
+ HBytes_Value *hb;
+ Something_Var sth;
} HBytes_Var;
-void fini_hbv(Tcl_Interp *ip, int rc, HBytes_Var *agg);
+/* from maskmap.c */
+
+typedef struct MaskMap_Value MaskMap_Value;
+
+typedef struct {
+ MaskMap_Value *mm;
+ Something_Var sth;
+} MaskMap_Var;
+
+extern Tcl_ObjType maskmap_type;
/* from chop.c */
/* only do_... functions declared in tables.h */
typedef struct {
const char *name;
int pad, use_algname;
-} PadMethod;
+} PadOp;
extern Tcl_ObjType blockcipherkey_type;
/* from algtables.c */
+typedef struct {
+ const char *name;
+ int int_offset;
+} BlockCipherPropInfo, HashAlgPropInfo;
+
typedef struct {
const char *name;
int hashsize, blocksize, statesize;
typedef struct {
const char *name;
int blocksize, schedule_size, key_min, key_max;
- void (*byteswap)(void *block);
BlockCipherPerDirectionInfo encrypt, decrypt;
} BlockCipherAlgInfo;
#define TALLOC(s) ((void*)Tcl_Alloc((s)))
#define TFREE(f) (Tcl_Free((void*)(f)))
+#define TREALLOC(p,l) ((void*)Tcl_Realloc((void*)(p),(l)))
#endif /*HBYTES_H*/
~ian / chiark-tcl.git / blobdiff