/*
*/
/*
+ * hbytes raw2h BINARY => hex
+ * hbytes h2raw HEX => binary
*
- * hbytes bin VAR => binary string
- * hbytes bin VAR VALUE => set
- *
- * hbytes prefix VAR [VALUE ...] = set VAR [concat VALUE ... $VAR]
- * hbytes append VAR [VALUE ...] = set VAR [concat $VAR VALUE ...]
- * hbytes concat VAR [VALUE ...] = set VAR [concat VALUE ...]
+ * hbytes prepend VAR [VALUE ...] = set VAR [concat VALUE ... $VAR]
+ * hbytes append VAR [VALUE ...] = set VAR [concat $VAR VALUE ...]
+ * hbytes concat VAR [VALUE ...] = set VAR [concat VALUE ...]
* hbytes unprepend VAR PREFIXLENGTH => prefix (removed from VAR)
* hbytes unappend VAR SUFFIXLENGTH => suffix (removed from VAR)
* hbytes chopto VAR NEWVARLENGTH => suffix (removed from VAR)
* (too short? error)
*
- * hbytes pkcs5 pv|uv VAR ALG => worked? (always 1 for p)
+ * hbytes pkcs5 pa|ua VAR ALG => worked? (always 1 for p)
* hbytes pkcs5 pn|un VAR BLOCKSIZE => worked? (always 1 for p)
- * hbytes blockcipher e|d VAR ALG MODE [IV] => IV
- * hbytes hash ALG VALUE => hash
- * hbytes hmac ALG VALUE KEY [MACLENGTH] => mac
+ * hbytes blockcipher d|e VAR ALG MODE [IV] => IV
+ *
+ * hbytes hash ALG MESSAGE => hash
+ * hbytes hmac ALG MESSAGE KEY [MACLENGTH] => mac
*
* Refs: HMAC: RFC2104
*/
/* from hbytes.c */
+/* Internal representation details: */
+#define HBYTES_ISEMPTY(hb) (!(hb)->begin_complex && !(hb)->end_0)
+#define HBYTES_ISSENTINEL(hb) (!(hb)->begin_complex && (hb)->end_0)
+#define HBYTES_ISSIMPLE(hb) ((hb)->begin_complex && (hb)->end_0)
+#define HBYTES_ISCOMPLEX(hb) ((hb)->begin_complex && !(hb)->end_0)
+
typedef struct {
- Byte *start, *end; /* always allocated dynamically */
+ void *begin_complex, *end_0;
} HBytes_Value; /* overlays internalRep */
+typedef struct {
+ Byte *dstart; /* always allocated dynamically */
+ int prespace, len, avail;
+ /*
+ * | SPARE | USED | SPARE |
+ * |<-prespace->|<-len->| |
+ * | |<----avail---->|
+ * ^start
+ */
+} HBytes_ComplexValue; /* pointed to from internalRep.otherValuePtr */
+
+/* Public interfaces: */
+
extern Tcl_ObjType hbytes_type;
+int hbytes_len(const HBytes_Value *v);
+Byte *hbytes_data(const HBytes_Value *v); /* caller may then modify data! */
+int hbytes_issentinel(const HBytes_Value *v);
+
+Byte *hbytes_prepend(HBytes_Value *upd, int el);
+Byte *hbytes_append(HBytes_Value *upd, int el);
+ /* return value is where to put the data */
+
+const Byte *hbytes_unprepend(HBytes_Value *upd, int rl);
+const Byte *hbytes_unappend(HBytes_Value *upd, int rl);
+ /* return value points to the removed data, which remains valid
+ * until next op on the HBytes_Value. If original value is
+ * shorter than rl or negative, returns 0 and does nothing. */
+
+void hbytes_empty(HBytes_Value *returns);
+void hbytes_sentinel(HBytes_Value *returns);
+void hbytes_array(HBytes_Value *returns, const Byte *array, int l);
+Byte *hbytes_arrayspace(HBytes_Value *returns, int l);
+void hbytes_free(HBytes_Value *frees);
+ /* _empty, _sentinel and _array do not free or read the old value;
+ * _free it first if needed. _free leaves it garbage, so you
+ * have to call _empty to reuse it. _arrayspace doesn't fill
+ * the array; you get a pointer and must fill it with data
+ * yourself. */
+
+/* The value made by hbytes_sentinel should not be passed to
+ * anything except HBYTES_IS..., and hbytes_free. */
+
+/* from hook.c */
+
int staticerr(Tcl_Interp *ip, const char *m);
void objfreeir(Tcl_Obj *o);
-Tcl_Obj *hbytes_set(Tcl_Obj *overwrite, const Byte *array, int l);
+/* from parse.c */
+
+typedef struct {
+ HBytes_Value *hb;
+ Tcl_Obj *obj, *var;
+} HBytes_Var;
+
+void fini_hbv(Tcl_Interp *ip, int rc, HBytes_Var *agg);
+
+/* from chop.c */
/* from enum.c */
extern Tcl_ObjType enum_nearlytype;
+extern Tcl_ObjType enum1_nearlytype;
const void *enum_lookup_cached_func(Tcl_Interp *ip, Tcl_Obj *o,
- size_t entrysize, const void *firstentry,
+ const void *firstentry, size_t entrysize,
const char *what);
#define enum_lookup_cached(ip,o,table,what) \
(enum_lookup_cached_func((ip),(o), \
* set to the error message.
*/
+int enum1_lookup_cached_func(Tcl_Interp *ip, Tcl_Obj *o,
+ const char *opts, const char *what);
+ /* -1 => error */
+
+/* from crypto.c */
+
+void memxor(Byte *dest, const Byte *src, int l);
+
+/* from hash.c */
+
+typedef struct {
+ int blocksize, hashsize;
+} HashAlgInfo;
+
+/* from blockciph.c */
+
+typedef struct {
+ void (*make_schedule)(void *schedule, const Byte *key, int keylen);
+ void (*crypt)(const void *schedule, const void *in, void *out);
+ /* in and out may be the same, but if they aren't they may not overlap */
+ /* in and out for crypt will have been through block_byteswap */
+} BlockCipherDirectionInfo;
+
+typedef struct {
+ const char *name;
+ int blocksize, schedule_size, key_min, key_max;
+ void (*byteswap)(Byte *block);
+ BlockCipherDirectionInfo encrypt, decrypt;
+} BlockCipherAlgInfo;
+
+extern const BlockCipherAlgInfo blockcipheralginfos[];
+
+/* from bcmode.c */
+
+typedef struct {
+ const char *name;
+ int iv_blocks, buf_blocks;
+ const char *(*encrypt)(Byte *data, int blocks,
+ const Byte *iv, Byte *buf,
+ const BlockCipherAlgInfo *alg, int encr,
+ int blocksize, const void *sch);
+ const char *(*decrypt)(Byte *data, int blocks,
+ const Byte *iv, Byte *buf,
+ const BlockCipherAlgInfo *alg, int encr,
+ int blocksize, const void *sch);
+ /* in each case, *iv is provided, but may be modified */
+} BlockCipherModeInfo;
+
+extern const BlockCipherModeInfo blockciphermodeinfos[];
+
/* useful macros */
-#define HBYTES(o) ((HBytes_Value*)&(o)->internalRep.twoPtrValue)
-#define HBYTES_LEN(o) (HBYTES((o))->end - HBYTES((o))->start)
+#define OBJ_HBYTES(o) ((HBytes_Value*)&(o)->internalRep.twoPtrValue)
#define TALLOC(s) ((void*)Tcl_Alloc((s)))
#define TFREE(f) (Tcl_Free((void*)(f)))
~ian / chiark-tcl.git / blobdiff