chiark / gitweb /
b6c0c9e2128e54ad06b137cb3f1d8928a87b2329
[chiark-tcl.git] / hbytes / hook.c
1 /*
2  */
3
4 #include <errno.h>
5
6 #include "hbytes.h"
7 #include "tables.h"
8
9 int staticerr(Tcl_Interp *ip, const char *m) {
10   Tcl_SetResult(ip, (char*)m, TCL_STATIC);
11   return TCL_ERROR;
12 }
13
14 int posixerr(Tcl_Interp *ip, int errnoval, const char *m) {
15   const char *em;
16   
17   Tcl_ResetResult(ip);
18   errno= errnoval;
19   em= Tcl_PosixError(ip);
20   Tcl_AppendResult(ip, m, ": ", em, (char*)0);
21   return TCL_ERROR;
22 }
23
24 void objfreeir(Tcl_Obj *o) {
25   if (o->typePtr && o->typePtr->freeIntRepProc)
26     o->typePtr->freeIntRepProc(o);
27   o->typePtr= 0;
28 }  
29
30 int do_hbytes_rep_info(ClientData cd, Tcl_Interp *ip,
31                        Tcl_Obj *obj, Tcl_Obj **result) {
32   const char *tn;
33   int nums[3], i, lnl;
34   Tcl_Obj *objl[4];
35
36   if (obj->typePtr == &hbytes_type) {
37     HBytes_Value *v= OBJ_HBYTES(obj);
38     memset(nums,0,sizeof(nums));
39     nums[1]= hbytes_len(v);
40   
41     if (HBYTES_ISEMPTY(v)) tn= "empty";
42     else if (HBYTES_ISSENTINEL(v)) tn= "sentinel!";
43     else if (HBYTES_ISSIMPLE(v)) tn= "simple";
44     else {
45       HBytes_ComplexValue *cx= v->begin_complex;
46       tn= "complex";
47       nums[0]= cx->prespace;
48       nums[2]= cx->avail - cx->len;
49     }
50     lnl= 3;
51   } else {
52     tn= "other";
53     lnl= 0;
54   }
55     
56   objl[0]= Tcl_NewStringObj((char*)tn,-1);
57   for (i=0; i<lnl; i++) objl[i+1]= Tcl_NewIntObj(nums[i]);
58   *result= Tcl_NewListObj(lnl+1,objl);
59     
60   return TCL_OK;
61 }
62
63 static void hbytes_t_dup(Tcl_Obj *src, Tcl_Obj *dup) {
64   objfreeir(dup);
65   hbytes_array(OBJ_HBYTES(dup),
66                hbytes_data(OBJ_HBYTES(src)),
67                hbytes_len(OBJ_HBYTES(src)));
68 }
69
70 static void hbytes_t_free(Tcl_Obj *o) {
71   hbytes_free(OBJ_HBYTES(o));
72 }
73
74 void obj_updatestr_array(Tcl_Obj *o, const Byte *byte, int l) {
75   char *str;
76
77   str= o->bytes= TALLOC(l*2+1);
78   o->length= l*2;
79   while (l>0) {
80     sprintf(str,"%02x",*byte);
81     str+=2; byte++; l--;
82   }
83   *str= 0;
84 }
85
86 static void hbytes_t_ustr(Tcl_Obj *o) {
87   obj_updatestr_array(o,
88                       hbytes_data(OBJ_HBYTES(o)),
89                       hbytes_len(OBJ_HBYTES(o)));
90 }
91
92 static int hbytes_t_sfa(Tcl_Interp *ip, Tcl_Obj *o) {
93   char *str, *ep, *os;
94   Byte *startbytes, *bytes;
95   int l;
96   char cbuf[3];
97
98   os= str= Tcl_GetStringFromObj(o,&l);  assert(str);
99   objfreeir(o);
100
101   if (l & 1) return staticerr(ip, "hbytes: conversion from hex:"
102                               " odd length in hex");
103
104   startbytes= bytes= hbytes_arrayspace(OBJ_HBYTES(o), l/2);
105
106   cbuf[2]= 0;
107   while (l>0) {
108     cbuf[0]= *str++;
109     cbuf[1]= *str++;
110     *bytes++= strtoul(cbuf,&ep,16);
111     if (ep != cbuf+2) {
112       hbytes_free(OBJ_HBYTES(o));
113       return staticerr(ip, "hbytes: conversion from hex:"
114                        " bad hex digit");
115     }
116     l -= 2;
117   }
118
119   o->typePtr = &hbytes_type;
120   return TCL_OK;
121 }
122
123 Tcl_ObjType hbytes_type = {
124   "hbytes",
125   hbytes_t_free, hbytes_t_dup, hbytes_t_ustr, hbytes_t_sfa
126 };
127
128 int do_hbytes_raw2h(ClientData cd, Tcl_Interp *ip,
129                     Tcl_Obj *binary, HBytes_Value *result) {
130   const char *str;
131   int l;
132
133   str= Tcl_GetStringFromObj(binary,&l);
134   hbytes_array(result, str, l);
135   return TCL_OK;
136 }
137
138 int do_hbytes_h2raw(ClientData cd, Tcl_Interp *ip,
139                     HBytes_Value hex, Tcl_Obj **result) {
140   *result= Tcl_NewStringObj(hbytes_data(&hex), hbytes_len(&hex));
141   return TCL_OK;
142 }
143
144 int do_hbytes_length(ClientData cd, Tcl_Interp *ip,
145                      HBytes_Value v, int *result) {
146   *result= hbytes_len(&v);
147   return TCL_OK;
148 }
149
150 int do_hbytes_random(ClientData cd, Tcl_Interp *ip,
151                      int length, HBytes_Value *result) {
152   Byte *space;
153   int rc;
154   
155   space= hbytes_arrayspace(result, length);
156   rc= get_urandom(ip, space, length);
157   if (rc) { hbytes_free(result); return rc; }
158   return TCL_OK;
159 }  
160   
161 int do_hbytes_zeroes(ClientData cd, Tcl_Interp *ip,
162                      int length, HBytes_Value *result) {
163   Byte *space;
164   space= hbytes_arrayspace(result, length);
165   memset(space,0,length);
166   return TCL_OK;
167 }
168
169 int do__hbytes(ClientData cd, Tcl_Interp *ip,
170                const HBytes_SubCommand *subcmd,
171                int objc, Tcl_Obj *const *objv) {
172   return subcmd->func(0,ip,objc,objv);
173 }
174
175 #define URANDOM "/dev/urandom"
176
177 int get_urandom(Tcl_Interp *ip, Byte *buffer, int l) {
178   static FILE *urandom;
179
180   int r, esave;
181
182   if (!urandom) {
183     urandom= fopen(URANDOM,"rb");
184     if (!urandom) return posixerr(ip,errno,"open " URANDOM);
185   }
186   r= fread(buffer,1,l,urandom);
187   if (r==l) return 0;
188
189   esave= errno;
190   fclose(urandom); urandom=0;
191
192   if (ferror(urandom)) {
193     return posixerr(ip,errno,"read " URANDOM);
194   } else {
195     assert(feof(urandom));
196     return staticerr(ip, URANDOM " gave eof!");
197   }
198 }
199
200 int Hbytes_Init(Tcl_Interp *ip) {
201   Tcl_RegisterObjType(&hbytes_type);
202   Tcl_RegisterObjType(&blockcipherkey_type);
203   Tcl_RegisterObjType(&enum_nearlytype);
204   Tcl_RegisterObjType(&enum1_nearlytype);
205   Tcl_CreateObjCommand(ip,"hbytes", pa__hbytes,0,0);
206   return TCL_OK;
207 }