Unified · Split
| @@ -0,0 +1,82 @@ | ||
| 1 | +TARG=drawterm | |
| 2 | +CC=gcc | |
| 3 | +CFLAGS=-Iinclude -c -ggdb -D_THREAD_SAFE -pthread # not ready for this yet: -Wall | |
| 4 | +O=o | |
| 5 | +#CC=cl | |
| 6 | +#CFLAGS=-c -nologo -W3 -YX -Zi -MT -Zl -Iinclude -DWINDOWS | |
| 7 | +#O=obj | |
| 8 | + | |
| 9 | +OFILES=\ | |
| 10 | + main.$O\ | |
| 11 | + cpu.$O\ | |
| 12 | + readcons.$O\ | |
| 13 | + secstore.$O\ | |
| 14 | + latin1.$O\ | |
| 15 | + | |
| 16 | +LIBS=\ | |
| 17 | + kern/libkern.a\ | |
| 18 | + exportfs/libexportfs.a\ | |
| 19 | + libauthsrv/libauthsrv.a\ | |
| 20 | + libsec/libsec.a\ | |
| 21 | + libmp/libmp.a\ | |
| 22 | + libmemdraw/libmemdraw.a\ | |
| 23 | + libmemlayer/libmemlayer.a\ | |
| 24 | + libdraw/libdraw.a\ | |
| 25 | + libc/libc.a\ | |
| 26 | + kern/libkern.a\ | |
| 27 | + gui-x11/libx11.a\ | |
| 28 | + libmemdraw/libmemdraw.a\ | |
| 29 | + libdraw/libdraw.a\ | |
| 30 | + kern/libkern.a\ | |
| 31 | + libc/libc.a\ | |
| 32 | + libmemdraw/libmemdraw.a\ | |
| 33 | + libmemlayer/libmemlayer.a\ | |
| 34 | + libdraw/libdraw.a\ | |
| 35 | + libmachdep.a | |
| 36 | + | |
| 37 | +$(TARG): $(OFILES) $(LIBS) | |
| 38 | + $(CC) -pthread -o $(TARG) $(OFILES) $(LIBS) -L/usr/X11R6/lib -lX11 -ggdb | |
| 39 | + | |
| 40 | +%.$O: %.c | |
| 41 | + $(CC) $(CFLAGS) $*.c | |
| 42 | + | |
| 43 | +clean: | |
| 44 | + rm -f *.o */*.o */*.a drawterm *.a | |
| 45 | + | |
| 46 | +kern/libkern.a: | |
| 47 | + (cd kern; make) | |
| 48 | + | |
| 49 | +exportfs/libexportfs.a: | |
| 50 | + (cd exportfs; make) | |
| 51 | + | |
| 52 | +libauthsrv/libauthsrv.a: | |
| 53 | + (cd libauthsrv; make) | |
| 54 | + | |
| 55 | +libmp/libmp.a: | |
| 56 | + (cd libmp; make) | |
| 57 | + | |
| 58 | +libsec/libsec.a: | |
| 59 | + (cd libsec; make) | |
| 60 | + | |
| 61 | +libmemdraw/libmemdraw.a: | |
| 62 | + (cd libmemdraw; make) | |
| 63 | + | |
| 64 | +libmemlayer/libmemlayer.a: | |
| 65 | + (cd libmemlayer; make) | |
| 66 | + | |
| 67 | +libdraw/libdraw.a: | |
| 68 | + (cd libdraw; make) | |
| 69 | + | |
| 70 | +libc/libc.a: | |
| 71 | + (cd libc; make) | |
| 72 | + | |
| 73 | +gui-x11/libx11.a: | |
| 74 | + (cd gui-x11; make) | |
| 75 | + | |
| 76 | +#libmachdep.a: | |
| 77 | +# arch=`uname -m|sed 's/i.86/386/;s/Power Macintosh/power/'`; \ | |
| 78 | +# (cd gcc$$arch && make) | |
| 79 | + | |
| 80 | +libmachdep.a: | |
| 81 | + (cd posix-386; make) | |
| 82 | + | |
| @@ -0,0 +1,16 @@ | ||
| 1 | + | |
| 2 | +Win32 port Notes: | |
| 3 | + | |
| 4 | +* Issues: | |
| 5 | + | |
| 6 | + ** ownership questions on files are completely deferred by | |
| 7 | + marking them as unknown. It works for now, but probably | |
| 8 | + should be handled correctly. | |
| 9 | + | |
| 10 | + ** No performance measurements have been done. The interactive | |
| 11 | + response seems faster than old drawterm, but the i/o seems | |
| 12 | + slower. | |
| 13 | + | |
| 14 | + ** fs functions in devntfs.c need to handle conversions to/from | |
| 15 | + widechar and utf-8. | |
| 16 | + | |
| @@ -0,0 +1,20 @@ | ||
| 1 | +extern char *argv0; | |
| 2 | +#define ARGBEGIN for((argv0? 0: (argv0=*argv)),argv++,argc--;\ | |
| 3 | + argv[0] && argv[0][0]=='-' && argv[0][1];\ | |
| 4 | + argc--, argv++) {\ | |
| 5 | + char *_args, *_argt;\ | |
| 6 | + Rune _argc;\ | |
| 7 | + _args = &argv[0][1];\ | |
| 8 | + if(_args[0]=='-' && _args[1]==0){\ | |
| 9 | + argc--; argv++; break;\ | |
| 10 | + }\ | |
| 11 | + _argc = 0;\ | |
| 12 | + while(*_args && (_args += chartorune(&_argc, _args)))\ | |
| 13 | + switch(_argc) | |
| 14 | +#define ARGEND SET(_argt);USED(_argt); USED(_argc); USED(_args);}USED(argv); USED(argc); | |
| 15 | +#define ARGF() (_argt=_args, _args="",\ | |
| 16 | + (*_argt? _argt: argv[1]? (argc--, *++argv): 0)) | |
| 17 | +#define ARGC() _argc | |
| 18 | + | |
| 19 | +#define EARGF(x) (_argt=_args, _args="",\ | |
| 20 | + (*_argt? _argt: argv[1]? (argc--, *++argv): (x, (char*)0))) | |
| @@ -0,0 +1,606 @@ | ||
| 1 | +/* | |
| 2 | + * cpu.c - Make a connection to a cpu server | |
| 3 | + * | |
| 4 | + * Invoked by listen as 'cpu -R | -N service net netdir' | |
| 5 | + * by users as 'cpu [-h system] [-c cmd args ...]' | |
| 6 | + */ | |
| 7 | + | |
| 8 | +#include <u.h> | |
| 9 | +#include <libc.h> | |
| 10 | +#include <auth.h> | |
| 11 | +#include <fcall.h> | |
| 12 | +#include <authsrv.h> | |
| 13 | +#include <libsec.h> | |
| 14 | +#include "args.h" | |
| 15 | +#include "drawterm.h" | |
| 16 | + | |
| 17 | +#define Maxfdata 8192 | |
| 18 | +#define MaxStr 128 | |
| 19 | + | |
| 20 | +static char* getuser(void); | |
| 21 | +static void fatal(int, char*, ...); | |
| 22 | +static void catcher(void*, char*); | |
| 23 | +static void usage(void); | |
| 24 | +static void writestr(int, char*, char*, int); | |
| 25 | +static int readstr(int, char*, int); | |
| 26 | +static char *rexcall(int*, char*, char*); | |
| 27 | +static int setamalg(char*); | |
| 28 | +static char *keyspec = ""; | |
| 29 | +static AuthInfo *p9any(int); | |
| 30 | + | |
| 31 | +static int notechan; | |
| 32 | +#define system csystem | |
| 33 | +static char *system; | |
| 34 | +static int cflag; | |
| 35 | +int dbg; | |
| 36 | + | |
| 37 | +static char *srvname = "ncpu"; | |
| 38 | +static char *ealgs = "rc4_256 sha1"; | |
| 39 | + | |
| 40 | +/* message size for exportfs; may be larger so we can do big graphics in CPU window */ | |
| 41 | +static int msgsize = Maxfdata+IOHDRSZ; | |
| 42 | + | |
| 43 | +/* authentication mechanisms */ | |
| 44 | +static int netkeyauth(int); | |
| 45 | +static int netkeysrvauth(int, char*); | |
| 46 | +static int p9auth(int); | |
| 47 | +static int srvp9auth(int, char*); | |
| 48 | +static int noauth(int); | |
| 49 | +static int srvnoauth(int, char*); | |
| 50 | + | |
| 51 | +char *authserver; | |
| 52 | + | |
| 53 | +typedef struct AuthMethod AuthMethod; | |
| 54 | +struct AuthMethod { | |
| 55 | + char *name; /* name of method */ | |
| 56 | + int (*cf)(int); /* client side authentication */ | |
| 57 | + int (*sf)(int, char*); /* server side authentication */ | |
| 58 | +} authmethod[] = | |
| 59 | +{ | |
| 60 | + { "p9", p9auth, srvp9auth,}, | |
| 61 | + { "netkey", netkeyauth, netkeysrvauth,}, | |
| 62 | +// { "none", noauth, srvnoauth,}, | |
| 63 | + { nil, nil} | |
| 64 | +}; | |
| 65 | +AuthMethod *am = authmethod; /* default is p9 */ | |
| 66 | + | |
| 67 | +char *p9authproto = "p9any"; | |
| 68 | + | |
| 69 | +int setam(char*); | |
| 70 | + | |
| 71 | +void | |
| 72 | +exits(char *s) | |
| 73 | +{ | |
| 74 | + print("\ngoodbye\n"); | |
| 75 | + for(;;) osyield(); | |
| 76 | +} | |
| 77 | + | |
| 78 | +void | |
| 79 | +usage(void) | |
| 80 | +{ | |
| 81 | + fprint(2, "usage: drawterm [-a authserver] [-c cpuserver] [-s secstore] [-u user]\n"); | |
| 82 | + exits("usage"); | |
| 83 | +} | |
| 84 | +int fdd; | |
| 85 | + | |
| 86 | +void | |
| 87 | +cpumain(int argc, char **argv) | |
| 88 | +{ | |
| 89 | + char dat[MaxStr], buf[MaxStr], cmd[MaxStr], *p, *err, *secstoreserver, *s; | |
| 90 | + int fd, ms, data; | |
| 91 | + | |
| 92 | + /* see if we should use a larger message size */ | |
| 93 | + fd = open("/dev/draw", OREAD); | |
| 94 | + if(fd > 0){ | |
| 95 | + ms = iounit(fd); | |
| 96 | + if(msgsize < ms+IOHDRSZ) | |
| 97 | + msgsize = ms+IOHDRSZ; | |
| 98 | + close(fd); | |
| 99 | + } | |
| 100 | + | |
| 101 | + user = readcons("user", getenv("USER"), 0); | |
| 102 | + secstoreserver = nil; | |
| 103 | + ARGBEGIN{ | |
| 104 | + case 'a': | |
| 105 | + authserver = EARGF(usage()); | |
| 106 | + break; | |
| 107 | + case 'e': | |
| 108 | + ealgs = EARGF(usage()); | |
| 109 | + if(*ealgs == 0 || strcmp(ealgs, "clear") == 0) | |
| 110 | + ealgs = nil; | |
| 111 | + break; | |
| 112 | + case 'd': | |
| 113 | + dbg++; | |
| 114 | + break; | |
| 115 | + case 'c': | |
| 116 | + system = EARGF(usage()); | |
| 117 | + break; | |
| 118 | +/* | |
| 119 | + case 'c': | |
| 120 | + cflag++; | |
| 121 | + cmd[0] = '!'; | |
| 122 | + cmd[1] = '\0'; | |
| 123 | + while(p = ARGF()) { | |
| 124 | + strcat(cmd, " "); | |
| 125 | + strcat(cmd, p); | |
| 126 | + } | |
| 127 | + break; | |
| 128 | +*/ | |
| 129 | + case 'u': | |
| 130 | + user = EARGF(usage()); | |
| 131 | + break; | |
| 132 | + case 's': | |
| 133 | + secstoreserver = EARGF(usage()); | |
| 134 | + break; | |
| 135 | + default: | |
| 136 | + usage(); | |
| 137 | + }ARGEND; | |
| 138 | + | |
| 139 | + if(secstoreserver == nil) | |
| 140 | + secstoreserver = authserver; | |
| 141 | + | |
| 142 | + if(secstoreserver && havesecstore(secstoreserver, user)){ | |
| 143 | + s = secstorefetch(secstoreserver, user, nil); | |
| 144 | + if(s){ | |
| 145 | + if(strlen(s) >= sizeof secstorebuf) | |
| 146 | + panic("secstore data too big"); | |
| 147 | + strcpy(secstorebuf, s); | |
| 148 | + } | |
| 149 | + } | |
| 150 | + | |
| 151 | + | |
| 152 | + if(argc != 0) | |
| 153 | + usage(); | |
| 154 | + | |
| 155 | + if(system == nil) { | |
| 156 | + p = getenv("cpu"); | |
| 157 | + if(p == 0) | |
| 158 | + fatal(0, "set $cpu"); | |
| 159 | + system = p; | |
| 160 | + } | |
| 161 | + | |
| 162 | + if(err = rexcall(&data, system, srvname)) | |
| 163 | + fatal(1, "%s: %s", err, system); | |
| 164 | + | |
| 165 | + /* Tell the remote side the command to execute and where our working directory is */ | |
| 166 | + if(cflag) | |
| 167 | + writestr(data, cmd, "command", 0); | |
| 168 | + if(getcwd(dat, sizeof(dat)) == 0) | |
| 169 | + writestr(data, "NO", "dir", 0); | |
| 170 | + else | |
| 171 | + writestr(data, dat, "dir", 0); | |
| 172 | + | |
| 173 | + /* | |
| 174 | + * Wait for the other end to execute and start our file service | |
| 175 | + * of /mnt/term | |
| 176 | + */ | |
| 177 | + if(readstr(data, buf, sizeof(buf)) < 0) | |
| 178 | + fatal(1, "waiting for FS: %r"); | |
| 179 | + if(strncmp("FS", buf, 2) != 0) { | |
| 180 | + print("remote cpu: %s", buf); | |
| 181 | + exits(buf); | |
| 182 | + } | |
| 183 | + | |
| 184 | + if(readstr(data, buf, sizeof buf) < 0) | |
| 185 | + fatal(1, "waiting for remote export: %r"); | |
| 186 | + if(strcmp(buf, "/") != 0){ | |
| 187 | + print("remote cpu: %s" , buf); | |
| 188 | + exits(buf); | |
| 189 | + } | |
| 190 | + write(data, "OK", 2); | |
| 191 | + | |
| 192 | + /* Begin serving the gnot namespace */ | |
| 193 | + exportfs(data, msgsize); | |
| 194 | + fatal(1, "starting exportfs"); | |
| 195 | +} | |
| 196 | + | |
| 197 | +void | |
| 198 | +fatal(int syserr, char *fmt, ...) | |
| 199 | +{ | |
| 200 | + Fmt f; | |
| 201 | + char *str; | |
| 202 | + va_list arg; | |
| 203 | + | |
| 204 | + fmtstrinit(&f); | |
| 205 | + fmtprint(&f, "cpu: "); | |
| 206 | + va_start(arg, fmt); | |
| 207 | + fmtvprint(&f, fmt, arg); | |
| 208 | + va_end(arg); | |
| 209 | + if(syserr) | |
| 210 | + fmtprint(&f, ": %r"); | |
| 211 | + fmtprint(&f, "\n"); | |
| 212 | + str = fmtstrflush(&f); | |
| 213 | + write(2, str, strlen(str)); | |
| 214 | + exits(str); | |
| 215 | +} | |
| 216 | + | |
| 217 | +char *negstr = "negotiating authentication method"; | |
| 218 | + | |
| 219 | +char bug[256]; | |
| 220 | + | |
| 221 | +char* | |
| 222 | +rexcall(int *fd, char *host, char *service) | |
| 223 | +{ | |
| 224 | + char *na; | |
| 225 | + char dir[MaxStr]; | |
| 226 | + char err[ERRMAX]; | |
| 227 | + char msg[MaxStr]; | |
| 228 | + int n; | |
| 229 | + | |
| 230 | + na = netmkaddr(host, "tcp", "17010"); | |
| 231 | + if((*fd = dial(na, 0, dir, 0)) < 0) | |
| 232 | + return "can't dial"; | |
| 233 | + | |
| 234 | + /* negotiate authentication mechanism */ | |
| 235 | + if(ealgs != nil) | |
| 236 | + snprint(msg, sizeof(msg), "%s %s", am->name, ealgs); | |
| 237 | + else | |
| 238 | + snprint(msg, sizeof(msg), "%s", am->name); | |
| 239 | + writestr(*fd, msg, negstr, 0); | |
| 240 | + n = readstr(*fd, err, sizeof err); | |
| 241 | + if(n < 0) | |
| 242 | + return negstr; | |
| 243 | + if(*err){ | |
| 244 | + werrstr(err); | |
| 245 | + return negstr; | |
| 246 | + } | |
| 247 | + | |
| 248 | + /* authenticate */ | |
| 249 | + *fd = (*am->cf)(*fd); | |
| 250 | + if(*fd < 0) | |
| 251 | + return "can't authenticate"; | |
| 252 | + return 0; | |
| 253 | +} | |
| 254 | + | |
| 255 | +void | |
| 256 | +writestr(int fd, char *str, char *thing, int ignore) | |
| 257 | +{ | |
| 258 | + int l, n; | |
| 259 | + | |
| 260 | + l = strlen(str); | |
| 261 | + n = write(fd, str, l+1); | |
| 262 | + if(!ignore && n < 0) | |
| 263 | + fatal(1, "writing network: %s", thing); | |
| 264 | +} | |
| 265 | + | |
| 266 | +int | |
| 267 | +readstr(int fd, char *str, int len) | |
| 268 | +{ | |
| 269 | + int n; | |
| 270 | + | |
| 271 | + while(len) { | |
| 272 | + n = read(fd, str, 1); | |
| 273 | + if(n < 0) | |
| 274 | + return -1; | |
| 275 | + if(*str == '\0') | |
| 276 | + return 0; | |
| 277 | + str++; | |
| 278 | + len--; | |
| 279 | + } | |
| 280 | + return -1; | |
| 281 | +} | |
| 282 | + | |
| 283 | +static int | |
| 284 | +readln(char *buf, int n) | |
| 285 | +{ | |
| 286 | + int i; | |
| 287 | + char *p; | |
| 288 | + | |
| 289 | + n--; /* room for \0 */ | |
| 290 | + p = buf; | |
| 291 | + for(i=0; i<n; i++){ | |
| 292 | + if(read(0, p, 1) != 1) | |
| 293 | + break; | |
| 294 | + if(*p == '\n' || *p == '\r') | |
| 295 | + break; | |
| 296 | + p++; | |
| 297 | + } | |
| 298 | + *p = '\0'; | |
| 299 | + return p-buf; | |
| 300 | +} | |
| 301 | + | |
| 302 | +/* | |
| 303 | + * user level challenge/response | |
| 304 | + */ | |
| 305 | +static int | |
| 306 | +netkeyauth(int fd) | |
| 307 | +{ | |
| 308 | + char chall[32]; | |
| 309 | + char resp[32]; | |
| 310 | + | |
| 311 | + strecpy(chall, chall+sizeof chall, getuser()); | |
| 312 | + print("user[%s]: ", chall); | |
| 313 | + if(readln(resp, sizeof(resp)) < 0) | |
| 314 | + return -1; | |
| 315 | + if(*resp != 0) | |
| 316 | + strcpy(chall, resp); | |
| 317 | + writestr(fd, chall, "challenge/response", 1); | |
| 318 | + | |
| 319 | + for(;;){ | |
| 320 | + if(readstr(fd, chall, sizeof chall) < 0) | |
| 321 | + break; | |
| 322 | + if(*chall == 0) | |
| 323 | + return fd; | |
| 324 | + print("challenge: %s\nresponse: ", chall); | |
| 325 | + if(readln(resp, sizeof(resp)) < 0) | |
| 326 | + break; | |
| 327 | + writestr(fd, resp, "challenge/response", 1); | |
| 328 | + } | |
| 329 | + return -1; | |
| 330 | +} | |
| 331 | + | |
| 332 | +static int | |
| 333 | +netkeysrvauth(int fd, char *user) | |
| 334 | +{ | |
| 335 | + return -1; | |
| 336 | +} | |
| 337 | + | |
| 338 | +static void | |
| 339 | +mksecret(char *t, uchar *f) | |
| 340 | +{ | |
| 341 | + sprint(t, "%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux", | |
| 342 | + f[0], f[1], f[2], f[3], f[4], f[5], f[6], f[7], f[8], f[9]); | |
| 343 | +} | |
| 344 | + | |
| 345 | +/* | |
| 346 | + * plan9 authentication followed by rc4 encryption | |
| 347 | + */ | |
| 348 | +static int | |
| 349 | +p9auth(int fd) | |
| 350 | +{ | |
| 351 | + uchar key[16]; | |
| 352 | + uchar digest[SHA1dlen]; | |
| 353 | + char fromclientsecret[21]; | |
| 354 | + char fromserversecret[21]; | |
| 355 | + int i; | |
| 356 | + AuthInfo *ai; | |
| 357 | + | |
| 358 | + ai = p9any(fd); | |
| 359 | + if(ai == nil) | |
| 360 | + return -1; | |
| 361 | + memmove(key+4, ai->secret, ai->nsecret); | |
| 362 | + if(ealgs == nil) | |
| 363 | + return fd; | |
| 364 | + | |
| 365 | + /* exchange random numbers */ | |
| 366 | + srand(truerand()); | |
| 367 | + for(i = 0; i < 4; i++) | |
| 368 | + key[i] = rand(); | |
| 369 | + if(write(fd, key, 4) != 4) | |
| 370 | + return -1; | |
| 371 | + if(readn(fd, key+12, 4) != 4) | |
| 372 | + return -1; | |
| 373 | + | |
| 374 | + /* scramble into two secrets */ | |
| 375 | + sha1(key, sizeof(key), digest, nil); | |
| 376 | + mksecret(fromclientsecret, digest); | |
| 377 | + mksecret(fromserversecret, digest+10); | |
| 378 | + | |
| 379 | + /* set up encryption */ | |
| 380 | + i = pushssl(fd, ealgs, fromclientsecret, fromserversecret, nil); | |
| 381 | + if(i < 0) | |
| 382 | + werrstr("can't establish ssl connection: %r"); | |
| 383 | + return i; | |
| 384 | +} | |
| 385 | + | |
| 386 | +int | |
| 387 | +authdial(char *net, char *dom) | |
| 388 | +{ | |
| 389 | + int fd; | |
| 390 | + fd = dial(netmkaddr(authserver, "tcp", "567"), 0, 0, 0); | |
| 391 | + //print("authdial %d\n", fd); | |
| 392 | + return fd; | |
| 393 | +} | |
| 394 | + | |
| 395 | +static int | |
| 396 | +getastickets(Ticketreq *tr, char *trbuf, char *tbuf) | |
| 397 | +{ | |
| 398 | + int asfd, rv; | |
| 399 | + char *dom; | |
| 400 | + | |
| 401 | + dom = tr->authdom; | |
| 402 | + asfd = authdial(nil, dom); | |
| 403 | + if(asfd < 0) | |
| 404 | + return -1; | |
| 405 | + rv = _asgetticket(asfd, trbuf, tbuf); | |
| 406 | + close(asfd); | |
| 407 | + return rv; | |
| 408 | +} | |
| 409 | + | |
| 410 | +static int | |
| 411 | +mkserverticket(Ticketreq *tr, char *authkey, char *tbuf) | |
| 412 | +{ | |
| 413 | + int i; | |
| 414 | + Ticket t; | |
| 415 | + | |
| 416 | + if(strcmp(tr->authid, tr->hostid) != 0) | |
| 417 | + return -1; | |
| 418 | + memset(&t, 0, sizeof(t)); | |
| 419 | + memmove(t.chal, tr->chal, CHALLEN); | |
| 420 | + strcpy(t.cuid, tr->uid); | |
| 421 | + strcpy(t.suid, tr->uid); | |
| 422 | + for(i=0; i<DESKEYLEN; i++) | |
| 423 | + t.key[i] = fastrand(); | |
| 424 | + t.num = AuthTc; | |
| 425 | + convT2M(&t, tbuf, authkey); | |
| 426 | + t.num = AuthTs; | |
| 427 | + convT2M(&t, tbuf+TICKETLEN, authkey); | |
| 428 | + return 0; | |
| 429 | +} | |
| 430 | + | |
| 431 | +static int | |
| 432 | +gettickets(Ticketreq *tr, char *key, char *trbuf, char *tbuf) | |
| 433 | +{ | |
| 434 | + if(getastickets(tr, trbuf, tbuf) >= 0) | |
| 435 | + return 0; | |
| 436 | + return mkserverticket(tr, key, tbuf); | |
| 437 | +} | |
| 438 | + | |
| 439 | +AuthInfo* | |
| 440 | +p9any(int fd) | |
| 441 | +{ | |
| 442 | + char buf[1024], buf2[1024], cchal[CHALLEN], *bbuf, *p, *dom, *u; | |
| 443 | + char *pass; | |
| 444 | + char tbuf[TICKETLEN+TICKETLEN+AUTHENTLEN], trbuf[TICKREQLEN]; | |
| 445 | + char authkey[DESKEYLEN]; | |
| 446 | + Authenticator auth; | |
| 447 | + int i, v2, n; | |
| 448 | + Ticketreq tr; | |
| 449 | + Ticket t; | |
| 450 | + AuthInfo *ai; | |
| 451 | + | |
| 452 | + if((n = readstr(fd, buf, sizeof buf)) < 0) | |
| 453 | + fatal(1, "cannot read p9any negotiation"); | |
| 454 | + bbuf = buf; | |
| 455 | + v2 = 0; | |
| 456 | + if(strncmp(buf, "v.2 ", 4) == 0){ | |
| 457 | + v2 = 1; | |
| 458 | + bbuf += 4; | |
| 459 | + } | |
| 460 | + if(p = strchr(bbuf, ' ')) | |
| 461 | + *p = 0; | |
| 462 | + p = bbuf; | |
| 463 | + if((dom = strchr(p, '@')) == nil) | |
| 464 | + fatal(1, "bad p9any domain"); | |
| 465 | + *dom++ = 0; | |
| 466 | + if(strcmp(p, "p9sk1") != 0) | |
| 467 | + fatal(1, "server did not offer p9sk1"); | |
| 468 | + | |
| 469 | + sprint(buf2, "%s %s", p, dom); | |
| 470 | + if(write(fd, buf2, strlen(buf2)+1) != strlen(buf2)+1) | |
| 471 | + fatal(1, "cannot write user/domain choice in p9any"); | |
| 472 | + if(v2){ | |
| 473 | + if((n = readstr(fd, buf, sizeof buf)) != 3) | |
| 474 | + fatal(1, "cannot read OK in p9any"); | |
| 475 | + if(memcmp(buf, "OK\0", 3) != 0) | |
| 476 | + fatal(1, "did not get OK in p9any"); | |
| 477 | + } | |
| 478 | + for(i=0; i<CHALLEN; i++) | |
| 479 | + cchal[i] = fastrand(); | |
| 480 | + if(write(fd, cchal, 8) != 8) | |
| 481 | + fatal(1, "cannot write p9sk1 challenge"); | |
| 482 | + | |
| 483 | + if(readn(fd, trbuf, TICKREQLEN) != TICKREQLEN) | |
| 484 | + fatal(1, "cannot read ticket request in p9sk1"); | |
| 485 | + | |
| 486 | + | |
| 487 | + convM2TR(trbuf, &tr); | |
| 488 | + u = user; | |
| 489 | + pass = findkey(&u, tr.authdom); | |
| 490 | + if(pass == nil) | |
| 491 | + again: | |
| 492 | + pass = getkey(u, tr.authdom); | |
| 493 | + if(pass == nil) | |
| 494 | + fatal(1, "no password"); | |
| 495 | + | |
| 496 | + passtokey(authkey, pass); | |
| 497 | + memset(pass, 0, strlen(pass)); | |
| 498 | + | |
| 499 | + tr.type = AuthTreq; | |
| 500 | + strecpy(tr.hostid, tr.hostid+sizeof tr.hostid, u); | |
| 501 | + strecpy(tr.uid, tr.uid+sizeof tr.uid, u); | |
| 502 | + convTR2M(&tr, trbuf); | |
| 503 | + | |
| 504 | + if(gettickets(&tr, authkey, trbuf, tbuf) < 0) | |
| 505 | + fatal(1, "cannot get auth tickets in p9sk1"); | |
| 506 | + | |
| 507 | + convM2T(tbuf, &t, authkey); | |
| 508 | + if(t.num != AuthTc){ | |
| 509 | + print("?password mismatch with auth server\n"); | |
| 510 | + goto again; | |
| 511 | + } | |
| 512 | + memmove(tbuf, tbuf+TICKETLEN, TICKETLEN); | |
| 513 | + | |
| 514 | + auth.num = AuthAc; | |
| 515 | + memmove(auth.chal, tr.chal, CHALLEN); | |
| 516 | + auth.id = 0; | |
| 517 | + convA2M(&auth, tbuf+TICKETLEN, t.key); | |
| 518 | + | |
| 519 | + if(write(fd, tbuf, TICKETLEN+AUTHENTLEN) != TICKETLEN+AUTHENTLEN) | |
| 520 | + fatal(1, "cannot send ticket and authenticator back in p9sk1"); | |
| 521 | + | |
| 522 | + if(readn(fd, tbuf, AUTHENTLEN) != AUTHENTLEN) | |
| 523 | + fatal(1, "cannot read authenticator in p9sk1"); | |
| 524 | + | |
| 525 | + convM2A(tbuf, &auth, t.key); | |
| 526 | + if(auth.num != AuthAs | |
| 527 | + || memcmp(auth.chal, cchal, CHALLEN) != 0 | |
| 528 | + || auth.id != 0){ | |
| 529 | + print("?you and auth server agree about password.\n"); | |
| 530 | + print("?server is confused.\n"); | |
| 531 | + fatal(1, "server lies got %llux.%d want %llux.%d", *(vlong*)auth.chal, auth.id, *(vlong*)cchal, 0); | |
| 532 | + } | |
| 533 | + //print("i am %s there.\n", t.suid); | |
| 534 | + ai = mallocz(sizeof(AuthInfo), 1); | |
| 535 | + ai->secret = mallocz(8, 1); | |
| 536 | + des56to64((uchar*)t.key, ai->secret); | |
| 537 | + ai->nsecret = 8; | |
| 538 | + ai->suid = strdup(t.suid); | |
| 539 | + ai->cuid = strdup(t.cuid); | |
| 540 | + memset(authkey, 0, sizeof authkey); | |
| 541 | + return ai; | |
| 542 | +} | |
| 543 | + | |
| 544 | +static int | |
| 545 | +noauth(int fd) | |
| 546 | +{ | |
| 547 | + ealgs = nil; | |
| 548 | + return fd; | |
| 549 | +} | |
| 550 | + | |
| 551 | +static int | |
| 552 | +srvnoauth(int fd, char *user) | |
| 553 | +{ | |
| 554 | + strecpy(user, user+MaxStr, getuser()); | |
| 555 | + ealgs = nil; | |
| 556 | + return fd; | |
| 557 | +} | |
| 558 | + | |
| 559 | +void | |
| 560 | +loghex(uchar *p, int n) | |
| 561 | +{ | |
| 562 | + char buf[100]; | |
| 563 | + int i; | |
| 564 | + | |
| 565 | + for(i = 0; i < n; i++) | |
| 566 | + sprint(buf+2*i, "%2.2ux", p[i]); | |
| 567 | +// syslog(0, "cpu", buf); | |
| 568 | +} | |
| 569 | + | |
| 570 | +static int | |
| 571 | +srvp9auth(int fd, char *user) | |
| 572 | +{ | |
| 573 | + return -1; | |
| 574 | +} | |
| 575 | + | |
| 576 | +/* | |
| 577 | + * set authentication mechanism | |
| 578 | + */ | |
| 579 | +int | |
| 580 | +setam(char *name) | |
| 581 | +{ | |
| 582 | + for(am = authmethod; am->name != nil; am++) | |
| 583 | + if(strcmp(am->name, name) == 0) | |
| 584 | + return 0; | |
| 585 | + am = authmethod; | |
| 586 | + return -1; | |
| 587 | +} | |
| 588 | + | |
| 589 | +/* | |
| 590 | + * set authentication mechanism and encryption/hash algs | |
| 591 | + */ | |
| 592 | +int | |
| 593 | +setamalg(char *s) | |
| 594 | +{ | |
| 595 | + ealgs = strchr(s, ' '); | |
| 596 | + if(ealgs != nil) | |
| 597 | + *ealgs++ = 0; | |
| 598 | + return setam(s); | |
| 599 | +} | |
| 600 | + | |
| 601 | +char* | |
| 602 | +getuser(void) | |
| 603 | +{ | |
| 604 | + return getenv("USER"); | |
| 605 | +} | |
| 606 | + | |
| @@ -0,0 +1,10 @@ | ||
| 1 | +extern int havesecstore(char *addr, char *owner); | |
| 2 | +extern char *secstore; | |
| 3 | +extern char secstorebuf[65536]; | |
| 4 | +extern char *secstorefetch(char *addr, char *owner, char *passwd); | |
| 5 | +extern char *authaddr; | |
| 6 | +extern char *readcons(char *prompt, char *def, int secret); | |
| 7 | +extern int exportfs(int, int); | |
| 8 | +extern char *user; | |
| 9 | +extern char *getkey(char*, char*); | |
| 10 | +extern char *findkey(char**, char*); | |
Binary file not shown.
| @@ -0,0 +1,72 @@ | ||
| 1 | +//Microsoft Developer Studio generated resource script. | |
| 2 | +// | |
| 3 | +#include "resource.h" | |
| 4 | + | |
| 5 | +#define APSTUDIO_READONLY_SYMBOLS | |
| 6 | +///////////////////////////////////////////////////////////////////////////// | |
| 7 | +// | |
| 8 | +// Generated from the TEXTINCLUDE 2 resource. | |
| 9 | +// | |
| 10 | +#include "afxres.h" | |
| 11 | + | |
| 12 | +///////////////////////////////////////////////////////////////////////////// | |
| 13 | +#undef APSTUDIO_READONLY_SYMBOLS | |
| 14 | + | |
| 15 | +///////////////////////////////////////////////////////////////////////////// | |
| 16 | +// English (U.S.) resources | |
| 17 | + | |
| 18 | +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) | |
| 19 | +#ifdef _WIN32 | |
| 20 | +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US | |
| 21 | +#pragma code_page(1252) | |
| 22 | +#endif //_WIN32 | |
| 23 | + | |
| 24 | +///////////////////////////////////////////////////////////////////////////// | |
| 25 | +// | |
| 26 | +// Icon | |
| 27 | +// | |
| 28 | + | |
| 29 | +// Icon with lowest ID value placed first to ensure application icon | |
| 30 | +// remains consistent on all systems. | |
| 31 | +IDI_ICON1 ICON DISCARDABLE "drawterm.ico" | |
| 32 | + | |
| 33 | +#ifdef APSTUDIO_INVOKED | |
| 34 | +///////////////////////////////////////////////////////////////////////////// | |
| 35 | +// | |
| 36 | +// TEXTINCLUDE | |
| 37 | +// | |
| 38 | + | |
| 39 | +1 TEXTINCLUDE DISCARDABLE | |
| 40 | +BEGIN | |
| 41 | + "resource.h\0" | |
| 42 | +END | |
| 43 | + | |
| 44 | +2 TEXTINCLUDE DISCARDABLE | |
| 45 | +BEGIN | |
| 46 | + "#include ""afxres.h""\r\n" | |
| 47 | + "\0" | |
| 48 | +END | |
| 49 | + | |
| 50 | +3 TEXTINCLUDE DISCARDABLE | |
| 51 | +BEGIN | |
| 52 | + "\r\n" | |
| 53 | + "\0" | |
| 54 | +END | |
| 55 | + | |
| 56 | +#endif // APSTUDIO_INVOKED | |
| 57 | + | |
| 58 | +#endif // English (U.S.) resources | |
| 59 | +///////////////////////////////////////////////////////////////////////////// | |
| 60 | + | |
| 61 | + | |
| 62 | + | |
| 63 | +#ifndef APSTUDIO_INVOKED | |
| 64 | +///////////////////////////////////////////////////////////////////////////// | |
| 65 | +// | |
| 66 | +// Generated from the TEXTINCLUDE 3 resource. | |
| 67 | +// | |
| 68 | + | |
| 69 | + | |
| 70 | +///////////////////////////////////////////////////////////////////////////// | |
| 71 | +#endif // not APSTUDIO_INVOKED | |
| 72 | + | |
Binary file not shown.
| @@ -0,0 +1,16 @@ | ||
| 1 | +LIB=libexportfs.a | |
| 2 | +CC=gcc | |
| 3 | +CFLAGS=-I../include -I. -I.. -c -ggdb -D_THREAD_SAFE -pthread | |
| 4 | +O=o | |
| 5 | + | |
| 6 | +OFILES=\ | |
| 7 | + exportfs.$O\ | |
| 8 | + exportsrv.$O | |
| 9 | + | |
| 10 | +$(LIB): $(OFILES) | |
| 11 | + ar r $(LIB) $(OFILES) | |
| 12 | + ranlib $(LIB) | |
| 13 | + | |
| 14 | +%.$O: %.c | |
| 15 | + $(CC) $(CFLAGS) $*.c | |
| 16 | + | |
| @@ -0,0 +1,503 @@ | ||
| 1 | +/* | |
| 2 | + * exportfs - Export a plan 9 name space across a network | |
| 3 | + */ | |
| 4 | +#include <u.h> | |
| 5 | +#include <libc.h> | |
| 6 | +#include <fcall.h> | |
| 7 | +#include <libsec.h> | |
| 8 | +#include "drawterm.h" | |
| 9 | +#define Extern | |
| 10 | +#include "exportfs.h" | |
| 11 | + | |
| 12 | +/* #define QIDPATH ((1LL<<48)-1) */ | |
| 13 | +#define QIDPATH ((((vlong)1)<<48)-1) | |
| 14 | +vlong newqid = 0; | |
| 15 | + | |
| 16 | +void (*fcalls[256])(Fsrpc*); | |
| 17 | + | |
| 18 | +/* accounting and debugging counters */ | |
| 19 | +int filecnt; | |
| 20 | +int freecnt; | |
| 21 | +int qidcnt; | |
| 22 | +int qfreecnt; | |
| 23 | +int ncollision; | |
| 24 | +int netfd; | |
| 25 | + | |
| 26 | +int | |
| 27 | +exportfs(int fd, int msgsz) | |
| 28 | +{ | |
| 29 | + char buf[ERRMAX], ebuf[ERRMAX]; | |
| 30 | + Fsrpc *r; | |
| 31 | + int n; | |
| 32 | + char *dbfile, *srv, *file; | |
| 33 | + ulong initial; | |
| 34 | + | |
| 35 | + fcalls[Tversion] = Xversion; | |
| 36 | + fcalls[Tauth] = Xauth; | |
| 37 | + fcalls[Tflush] = Xflush; | |
| 38 | + fcalls[Tattach] = Xattach; | |
| 39 | + fcalls[Twalk] = Xwalk; | |
| 40 | + fcalls[Topen] = slave; | |
| 41 | + fcalls[Tcreate] = Xcreate; | |
| 42 | + fcalls[Tclunk] = Xclunk; | |
| 43 | + fcalls[Tread] = slave; | |
| 44 | + fcalls[Twrite] = slave; | |
| 45 | + fcalls[Tremove] = Xremove; | |
| 46 | + fcalls[Tstat] = Xstat; | |
| 47 | + fcalls[Twstat] = Xwstat; | |
| 48 | + | |
| 49 | + srvfd = -1; | |
| 50 | + netfd = fd; | |
| 51 | + //dbg = 1; | |
| 52 | + | |
| 53 | + strcpy(buf, "this is buf"); | |
| 54 | + strcpy(ebuf, "this is ebuf"); | |
| 55 | + DEBUG(DFD, "exportfs: started\n"); | |
| 56 | + | |
| 57 | +// rfork(RFNOTEG); | |
| 58 | + | |
| 59 | + messagesize = msgsz; | |
| 60 | + if(messagesize == 0){ | |
| 61 | + messagesize = iounit(netfd); | |
| 62 | + if(messagesize == 0) | |
| 63 | + messagesize = 8192+IOHDRSZ; | |
| 64 | + } | |
| 65 | + | |
| 66 | + Workq = emallocz(sizeof(Fsrpc)*Nr_workbufs); | |
| 67 | +// for(i=0; i<Nr_workbufs; i++) | |
| 68 | +// Workq[i].buf = emallocz(messagesize); | |
| 69 | + fhash = emallocz(sizeof(Fid*)*FHASHSIZE); | |
| 70 | + | |
| 71 | + fmtinstall('F', fcallfmt); | |
| 72 | + | |
| 73 | + initroot(); | |
| 74 | + | |
| 75 | + DEBUG(DFD, "exportfs: %s\n", buf); | |
| 76 | + | |
| 77 | + /* | |
| 78 | + * Start serving file requests from the network | |
| 79 | + */ | |
| 80 | + for(;;) { | |
| 81 | + r = getsbuf(); | |
| 82 | + if(r == 0) | |
| 83 | + fatal("Out of service buffers"); | |
| 84 | + | |
| 85 | + DEBUG(DFD, "read9p..."); | |
| 86 | + n = read9pmsg(netfd, r->buf, messagesize); | |
| 87 | + if(n <= 0) | |
| 88 | + fatal(nil); | |
| 89 | + | |
| 90 | + if(convM2S(r->buf, n, &r->work) == 0) | |
| 91 | + fatal("convM2S format error"); | |
| 92 | + | |
| 93 | + DEBUG(DFD, "%F\n", &r->work); | |
| 94 | + (fcalls[r->work.type])(r); | |
| 95 | + } | |
| 96 | +} | |
| 97 | + | |
| 98 | +void | |
| 99 | +reply(Fcall *r, Fcall *t, char *err) | |
| 100 | +{ | |
| 101 | + uchar *data; | |
| 102 | + int m, n; | |
| 103 | + | |
| 104 | + t->tag = r->tag; | |
| 105 | + t->fid = r->fid; | |
| 106 | + if(err) { | |
| 107 | + t->type = Rerror; | |
| 108 | + t->ename = err; | |
| 109 | + } | |
| 110 | + else | |
| 111 | + t->type = r->type + 1; | |
| 112 | + | |
| 113 | + DEBUG(DFD, "\t%F\n", t); | |
| 114 | + | |
| 115 | + data = malloc(messagesize); /* not mallocz; no need to clear */ | |
| 116 | + if(data == nil) | |
| 117 | + fatal(Enomem); | |
| 118 | + n = convS2M(t, data, messagesize); | |
| 119 | + if((m=write(netfd, data, n))!=n){ | |
| 120 | + fprint(2, "wrote %d got %d (%r)\n", n, m); | |
| 121 | + fatal("write"); | |
| 122 | + } | |
| 123 | + free(data); | |
| 124 | +} | |
| 125 | + | |
| 126 | +Fid * | |
| 127 | +getfid(int nr) | |
| 128 | +{ | |
| 129 | + Fid *f; | |
| 130 | + | |
| 131 | + for(f = fidhash(nr); f; f = f->next) | |
| 132 | + if(f->nr == nr) | |
| 133 | + return f; | |
| 134 | + | |
| 135 | + return 0; | |
| 136 | +} | |
| 137 | + | |
| 138 | +int | |
| 139 | +freefid(int nr) | |
| 140 | +{ | |
| 141 | + Fid *f, **l; | |
| 142 | + char buf[128]; | |
| 143 | + | |
| 144 | + l = &fidhash(nr); | |
| 145 | + for(f = *l; f; f = f->next) { | |
| 146 | + if(f->nr == nr) { | |
| 147 | + if(f->mid) { | |
| 148 | + sprint(buf, "/mnt/exportfs/%d", f->mid); | |
| 149 | + unmount(0, buf); | |
| 150 | + psmap[f->mid] = 0; | |
| 151 | + } | |
| 152 | + if(f->f) { | |
| 153 | + freefile(f->f); | |
| 154 | + f->f = nil; | |
| 155 | + } | |
| 156 | + *l = f->next; | |
| 157 | + f->next = fidfree; | |
| 158 | + fidfree = f; | |
| 159 | + return 1; | |
| 160 | + } | |
| 161 | + l = &f->next; | |
| 162 | + } | |
| 163 | + | |
| 164 | + return 0; | |
| 165 | +} | |
| 166 | + | |
| 167 | +Fid * | |
| 168 | +newfid(int nr) | |
| 169 | +{ | |
| 170 | + Fid *new, **l; | |
| 171 | + int i; | |
| 172 | + | |
| 173 | + l = &fidhash(nr); | |
| 174 | + for(new = *l; new; new = new->next) | |
| 175 | + if(new->nr == nr) | |
| 176 | + return 0; | |
| 177 | + | |
| 178 | + if(fidfree == 0) { | |
| 179 | + fidfree = emallocz(sizeof(Fid) * Fidchunk); | |
| 180 | + | |
| 181 | + for(i = 0; i < Fidchunk-1; i++) | |
| 182 | + fidfree[i].next = &fidfree[i+1]; | |
| 183 | + | |
| 184 | + fidfree[Fidchunk-1].next = 0; | |
| 185 | + } | |
| 186 | + | |
| 187 | + new = fidfree; | |
| 188 | + fidfree = new->next; | |
| 189 | + | |
| 190 | + memset(new, 0, sizeof(Fid)); | |
| 191 | + new->next = *l; | |
| 192 | + *l = new; | |
| 193 | + new->nr = nr; | |
| 194 | + new->fid = -1; | |
| 195 | + new->mid = 0; | |
| 196 | + | |
| 197 | + return new; | |
| 198 | +} | |
| 199 | + | |
| 200 | +Fsrpc * | |
| 201 | +getsbuf(void) | |
| 202 | +{ | |
| 203 | + static int ap; | |
| 204 | + int look, rounds; | |
| 205 | + Fsrpc *wb; | |
| 206 | + int small_instead_of_fast = 1; | |
| 207 | + | |
| 208 | + if(small_instead_of_fast) | |
| 209 | + ap = 0; /* so we always start looking at the beginning and reuse buffers */ | |
| 210 | + | |
| 211 | + for(rounds = 0; rounds < 10; rounds++) { | |
| 212 | + for(look = 0; look < Nr_workbufs; look++) { | |
| 213 | + if(++ap == Nr_workbufs) | |
| 214 | + ap = 0; | |
| 215 | + if(Workq[ap].busy == 0) | |
| 216 | + break; | |
| 217 | + } | |
| 218 | + | |
| 219 | + if(look == Nr_workbufs){ | |
| 220 | + sleep(10 * rounds); | |
| 221 | + continue; | |
| 222 | + } | |
| 223 | + | |
| 224 | + wb = &Workq[ap]; | |
| 225 | + wb->pid = 0; | |
| 226 | + wb->canint = 0; | |
| 227 | + wb->flushtag = NOTAG; | |
| 228 | + wb->busy = 1; | |
| 229 | + if(wb->buf == nil) /* allocate buffers dynamically to keep size down */ | |
| 230 | + wb->buf = emallocz(messagesize); | |
| 231 | + return wb; | |
| 232 | + } | |
| 233 | + fatal("No more work buffers"); | |
| 234 | + return nil; | |
| 235 | +} | |
| 236 | + | |
| 237 | +void | |
| 238 | +freefile(File *f) | |
| 239 | +{ | |
| 240 | + File *parent, *child; | |
| 241 | + | |
| 242 | +Loop: | |
| 243 | + f->ref--; | |
| 244 | + if(f->ref > 0) | |
| 245 | + return; | |
| 246 | + freecnt++; | |
| 247 | + if(f->ref < 0) abort(); | |
| 248 | + DEBUG(DFD, "free %s\n", f->name); | |
| 249 | + /* delete from parent */ | |
| 250 | + parent = f->parent; | |
| 251 | + if(parent->child == f) | |
| 252 | + parent->child = f->childlist; | |
| 253 | + else{ | |
| 254 | + for(child=parent->child; child->childlist!=f; child=child->childlist) | |
| 255 | + if(child->childlist == nil) | |
| 256 | + fatal("bad child list"); | |
| 257 | + child->childlist = f->childlist; | |
| 258 | + } | |
| 259 | + freeqid(f->qidt); | |
| 260 | + free(f->name); | |
| 261 | + f->name = nil; | |
| 262 | + free(f); | |
| 263 | + f = parent; | |
| 264 | + if(f != nil) | |
| 265 | + goto Loop; | |
| 266 | +} | |
| 267 | + | |
| 268 | +File * | |
| 269 | +file(File *parent, char *name) | |
| 270 | +{ | |
| 271 | + Dir *dir; | |
| 272 | + char *path; | |
| 273 | + File *f; | |
| 274 | + | |
| 275 | + DEBUG(DFD, "\tfile: 0x%p %s name %s\n", parent, parent->name, name); | |
| 276 | + | |
| 277 | + path = makepath(parent, name); | |
| 278 | + dir = dirstat(path); | |
| 279 | + free(path); | |
| 280 | + if(dir == nil) | |
| 281 | + return nil; | |
| 282 | + | |
| 283 | + for(f = parent->child; f; f = f->childlist) | |
| 284 | + if(strcmp(name, f->name) == 0) | |
| 285 | + break; | |
| 286 | + | |
| 287 | + if(f == nil){ | |
| 288 | + f = emallocz(sizeof(File)); | |
| 289 | + f->name = estrdup(name); | |
| 290 | + | |
| 291 | + f->parent = parent; | |
| 292 | + f->childlist = parent->child; | |
| 293 | + parent->child = f; | |
| 294 | + parent->ref++; | |
| 295 | + f->ref = 0; | |
| 296 | + filecnt++; | |
| 297 | + } | |
| 298 | + f->ref++; | |
| 299 | + f->qid.type = dir->qid.type; | |
| 300 | + f->qid.vers = dir->qid.vers; | |
| 301 | + f->qidt = uniqueqid(dir); | |
| 302 | + f->qid.path = f->qidt->uniqpath; | |
| 303 | + | |
| 304 | + f->inval = 0; | |
| 305 | + | |
| 306 | + free(dir); | |
| 307 | + | |
| 308 | + return f; | |
| 309 | +} | |
| 310 | + | |
| 311 | +void | |
| 312 | +initroot(void) | |
| 313 | +{ | |
| 314 | + Dir *dir; | |
| 315 | + | |
| 316 | + root = emallocz(sizeof(File)); | |
| 317 | + root->name = estrdup("."); | |
| 318 | + | |
| 319 | + dir = dirstat(root->name); | |
| 320 | + if(dir == nil) | |
| 321 | + fatal("root stat"); | |
| 322 | + | |
| 323 | + root->ref = 1; | |
| 324 | + root->qid.vers = dir->qid.vers; | |
| 325 | + root->qidt = uniqueqid(dir); | |
| 326 | + root->qid.path = root->qidt->uniqpath; | |
| 327 | + root->qid.type = QTDIR; | |
| 328 | + free(dir); | |
| 329 | + | |
| 330 | + psmpt = emallocz(sizeof(File)); | |
| 331 | + psmpt->name = estrdup("/"); | |
| 332 | + | |
| 333 | + dir = dirstat(psmpt->name); | |
| 334 | + if(dir == nil) | |
| 335 | + return; | |
| 336 | + | |
| 337 | + psmpt->ref = 1; | |
| 338 | + psmpt->qid.vers = dir->qid.vers; | |
| 339 | + psmpt->qidt = uniqueqid(dir); | |
| 340 | + psmpt->qid.path = psmpt->qidt->uniqpath; | |
| 341 | + free(dir); | |
| 342 | + | |
| 343 | + psmpt = file(psmpt, "mnt"); | |
| 344 | + if(psmpt == 0) | |
| 345 | + return; | |
| 346 | + psmpt = file(psmpt, "exportfs"); | |
| 347 | +} | |
| 348 | + | |
| 349 | +char* | |
| 350 | +makepath(File *p, char *name) | |
| 351 | +{ | |
| 352 | + int i, n; | |
| 353 | + char *c, *s, *path, *seg[256]; | |
| 354 | + | |
| 355 | + seg[0] = name; | |
| 356 | + n = strlen(name)+2; | |
| 357 | + for(i = 1; i < 256 && p; i++, p = p->parent){ | |
| 358 | + seg[i] = p->name; | |
| 359 | + n += strlen(p->name)+1; | |
| 360 | + } | |
| 361 | + path = malloc(n); | |
| 362 | + if(path == nil) | |
| 363 | + fatal("out of memory"); | |
| 364 | + s = path; | |
| 365 | + | |
| 366 | + while(i--) { | |
| 367 | + for(c = seg[i]; *c; c++) | |
| 368 | + *s++ = *c; | |
| 369 | + *s++ = '/'; | |
| 370 | + } | |
| 371 | + while(s[-1] == '/') | |
| 372 | + s--; | |
| 373 | + *s = '\0'; | |
| 374 | + | |
| 375 | + return path; | |
| 376 | +} | |
| 377 | + | |
| 378 | +int | |
| 379 | +qidhash(vlong path) | |
| 380 | +{ | |
| 381 | + int h, n; | |
| 382 | + | |
| 383 | + h = 0; | |
| 384 | + for(n=0; n<64; n+=Nqidbits){ | |
| 385 | + h ^= path; | |
| 386 | + path >>= Nqidbits; | |
| 387 | + } | |
| 388 | + return h & (Nqidtab-1); | |
| 389 | +} | |
| 390 | + | |
| 391 | +void | |
| 392 | +freeqid(Qidtab *q) | |
| 393 | +{ | |
| 394 | + ulong h; | |
| 395 | + Qidtab *l; | |
| 396 | + | |
| 397 | + q->ref--; | |
| 398 | + if(q->ref > 0) | |
| 399 | + return; | |
| 400 | + qfreecnt++; | |
| 401 | + h = qidhash(q->path); | |
| 402 | + if(qidtab[h] == q) | |
| 403 | + qidtab[h] = q->next; | |
| 404 | + else{ | |
| 405 | + for(l=qidtab[h]; l->next!=q; l=l->next) | |
| 406 | + if(l->next == nil) | |
| 407 | + fatal("bad qid list"); | |
| 408 | + l->next = q->next; | |
| 409 | + } | |
| 410 | + free(q); | |
| 411 | +} | |
| 412 | + | |
| 413 | +Qidtab* | |
| 414 | +qidlookup(Dir *d) | |
| 415 | +{ | |
| 416 | + ulong h; | |
| 417 | + Qidtab *q; | |
| 418 | + | |
| 419 | + h = qidhash(d->qid.path); | |
| 420 | + for(q=qidtab[h]; q!=nil; q=q->next) | |
| 421 | + if(q->type==d->type && q->dev==d->dev && q->path==d->qid.path) | |
| 422 | + return q; | |
| 423 | + return nil; | |
| 424 | +} | |
| 425 | + | |
| 426 | +int | |
| 427 | +qidexists(vlong path) | |
| 428 | +{ | |
| 429 | + int h; | |
| 430 | + Qidtab *q; | |
| 431 | + | |
| 432 | + for(h=0; h<Nqidtab; h++) | |
| 433 | + for(q=qidtab[h]; q!=nil; q=q->next) | |
| 434 | + if(q->uniqpath == path) | |
| 435 | + return 1; | |
| 436 | + return 0; | |
| 437 | +} | |
| 438 | + | |
| 439 | +Qidtab* | |
| 440 | +uniqueqid(Dir *d) | |
| 441 | +{ | |
| 442 | + ulong h; | |
| 443 | + vlong path; | |
| 444 | + Qidtab *q; | |
| 445 | + | |
| 446 | + q = qidlookup(d); | |
| 447 | + if(q != nil){ | |
| 448 | + q->ref++; | |
| 449 | + return q; | |
| 450 | + } | |
| 451 | + path = d->qid.path; | |
| 452 | + while(qidexists(path)){ | |
| 453 | + DEBUG(DFD, "collision on %s\n", d->name); | |
| 454 | + /* collision: find a new one */ | |
| 455 | + ncollision++; | |
| 456 | + path &= QIDPATH; | |
| 457 | + ++newqid; | |
| 458 | + if(newqid >= (1<<16)){ | |
| 459 | + DEBUG(DFD, "collision wraparound\n"); | |
| 460 | + newqid = 1; | |
| 461 | + } | |
| 462 | + path |= newqid<<48; | |
| 463 | + DEBUG(DFD, "assign qid %.16llux\n", path); | |
| 464 | + } | |
| 465 | + q = mallocz(sizeof(Qidtab), 1); | |
| 466 | + if(q == nil) | |
| 467 | + fatal("no memory for qid table"); | |
| 468 | + qidcnt++; | |
| 469 | + q->ref = 1; | |
| 470 | + q->type = d->type; | |
| 471 | + q->dev = d->dev; | |
| 472 | + q->path = d->qid.path; | |
| 473 | + q->uniqpath = path; | |
| 474 | + h = qidhash(d->qid.path); | |
| 475 | + q->next = qidtab[h]; | |
| 476 | + qidtab[h] = q; | |
| 477 | + return q; | |
| 478 | +} | |
| 479 | + | |
| 480 | +void | |
| 481 | +fatal(char *s, ...) | |
| 482 | +{ | |
| 483 | + char buf[ERRMAX]; | |
| 484 | + va_list arg; | |
| 485 | + Proc *m; | |
| 486 | + | |
| 487 | + if (s) { | |
| 488 | + va_start(arg, s); | |
| 489 | + vsnprint(buf, ERRMAX, s, arg); | |
| 490 | + va_end(arg); | |
| 491 | + } | |
| 492 | + | |
| 493 | + /* Clear away the slave children */ | |
| 494 | +// for(m = Proclist; m; m = m->next) | |
| 495 | +// postnote(PNPROC, m->pid, "kill"); | |
| 496 | + | |
| 497 | + DEBUG(DFD, "%s\n", buf); | |
| 498 | + if (s) | |
| 499 | + sysfatal(buf); | |
| 500 | + else | |
| 501 | + exits(nil); | |
| 502 | +} | |
| 503 | + | |
| @@ -0,0 +1,148 @@ | ||
| 1 | +/* | |
| 2 | + * exportfs.h - definitions for exporting file server | |
| 3 | + */ | |
| 4 | + | |
| 5 | +#define DEBUG if(!dbg){}else fprint | |
| 6 | +#define DFD 2 | |
| 7 | +#define fidhash(s) fhash[s%FHASHSIZE] | |
| 8 | + | |
| 9 | +#define Proc Exproc | |
| 10 | + | |
| 11 | + | |
| 12 | +typedef struct Fsrpc Fsrpc; | |
| 13 | +typedef struct Fid Fid; | |
| 14 | +typedef struct File File; | |
| 15 | +typedef struct Proc Proc; | |
| 16 | +typedef struct Qidtab Qidtab; | |
| 17 | + | |
| 18 | +struct Fsrpc | |
| 19 | +{ | |
| 20 | + int busy; /* Work buffer has pending rpc to service */ | |
| 21 | + int pid; /* Pid of slave process executing the rpc */ | |
| 22 | + int canint; /* Interrupt gate */ | |
| 23 | + int flushtag; /* Tag on which to reply to flush */ | |
| 24 | + Fcall work; /* Plan 9 incoming Fcall */ | |
| 25 | + uchar *buf; /* Data buffer */ | |
| 26 | +}; | |
| 27 | + | |
| 28 | +struct Fid | |
| 29 | +{ | |
| 30 | + int fid; /* system fd for i/o */ | |
| 31 | + File *f; /* File attached to this fid */ | |
| 32 | + int mode; | |
| 33 | + int nr; /* fid number */ | |
| 34 | + int mid; /* Mount id */ | |
| 35 | + Fid *next; /* hash link */ | |
| 36 | +}; | |
| 37 | + | |
| 38 | +struct File | |
| 39 | +{ | |
| 40 | + char *name; | |
| 41 | + int ref; | |
| 42 | + Qid qid; | |
| 43 | + Qidtab *qidt; | |
| 44 | + int inval; | |
| 45 | + File *parent; | |
| 46 | + File *child; | |
| 47 | + File *childlist; | |
| 48 | +}; | |
| 49 | + | |
| 50 | +struct Proc | |
| 51 | +{ | |
| 52 | + int pid; | |
| 53 | + int busy; | |
| 54 | + Proc *next; | |
| 55 | +}; | |
| 56 | + | |
| 57 | +struct Qidtab | |
| 58 | +{ | |
| 59 | + int ref; | |
| 60 | + int type; | |
| 61 | + int dev; | |
| 62 | + vlong path; | |
| 63 | + vlong uniqpath; | |
| 64 | + Qidtab *next; | |
| 65 | +}; | |
| 66 | + | |
| 67 | +enum | |
| 68 | +{ | |
| 69 | + MAXPROC = 50, | |
| 70 | + FHASHSIZE = 64, | |
| 71 | + Nr_workbufs = 50, | |
| 72 | + Fidchunk = 1000, | |
| 73 | + Npsmpt = 32, | |
| 74 | + Nqidbits = 5, | |
| 75 | + Nqidtab = (1<<Nqidbits), | |
| 76 | +}; | |
| 77 | + | |
| 78 | +#define Enomem Exenomem | |
| 79 | +#define Ebadfix Exebadfid | |
| 80 | +#define Enotdir Exenotdir | |
| 81 | +#define Edupfid Exedupfid | |
| 82 | +#define Eopen Exeopen | |
| 83 | +#define Exmnt Exexmnt | |
| 84 | +#define Emip Exemip | |
| 85 | +#define Enopsmt Exenopsmt | |
| 86 | + | |
| 87 | +extern char Ebadfid[]; | |
| 88 | +extern char Enotdir[]; | |
| 89 | +extern char Edupfid[]; | |
| 90 | +extern char Eopen[]; | |
| 91 | +extern char Exmnt[]; | |
| 92 | +extern char Enomem[]; | |
| 93 | +extern char Emip[]; | |
| 94 | +extern char Enopsmt[]; | |
| 95 | + | |
| 96 | +Extern Fsrpc *Workq; | |
| 97 | +Extern int dbg; | |
| 98 | +Extern File *root; | |
| 99 | +Extern File *psmpt; | |
| 100 | +Extern Fid **fhash; | |
| 101 | +Extern Fid *fidfree; | |
| 102 | +Extern Proc *Proclist; | |
| 103 | +Extern char psmap[Npsmpt]; | |
| 104 | +Extern Qidtab *qidtab[Nqidtab]; | |
| 105 | +Extern ulong messagesize; | |
| 106 | +Extern int srvfd; | |
| 107 | + | |
| 108 | +/* File system protocol service procedures */ | |
| 109 | +void Xattach(Fsrpc*); | |
| 110 | +void Xauth(Fsrpc*); | |
| 111 | +void Xclunk(Fsrpc*); | |
| 112 | +void Xcreate(Fsrpc*); | |
| 113 | +void Xflush(Fsrpc*); | |
| 114 | +void Xnop(Fsrpc*); | |
| 115 | +void Xremove(Fsrpc*); | |
| 116 | +void Xstat(Fsrpc*); | |
| 117 | +void Xversion(Fsrpc*); | |
| 118 | +void Xwalk(Fsrpc*); | |
| 119 | +void Xwstat(Fsrpc*); | |
| 120 | +void slave(Fsrpc*); | |
| 121 | + | |
| 122 | +void reply(Fcall*, Fcall*, char*); | |
| 123 | +Fid *getfid(int); | |
| 124 | +int freefid(int); | |
| 125 | +Fid *newfid(int); | |
| 126 | +Fsrpc *getsbuf(void); | |
| 127 | +void initroot(void); | |
| 128 | +void fatal(char*, ...); | |
| 129 | +char* makepath(File*, char*); | |
| 130 | +File *file(File*, char*); | |
| 131 | +void freefile(File*); | |
| 132 | +void slaveopen(Fsrpc*); | |
| 133 | +void slaveread(Fsrpc*); | |
| 134 | +void slavewrite(Fsrpc*); | |
| 135 | +void blockingslave(void*); | |
| 136 | +void reopen(Fid *f); | |
| 137 | +void noteproc(int, char*); | |
| 138 | +void flushaction(void*, char*); | |
| 139 | +void pushfcall(char*); | |
| 140 | +Qidtab* uniqueqid(Dir*); | |
| 141 | +void freeqid(Qidtab*); | |
| 142 | +char* estrdup(char*); | |
| 143 | +void* emallocz(uint); | |
| 144 | +int readmessage(int, char*, int); | |
| 145 | + | |
| 146 | +#define notify | |
| 147 | +#define noted | |
| 148 | +#define exits | |
| @@ -0,0 +1,679 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | +#include <fcall.h> | |
| 4 | +#define Extern extern | |
| 5 | +#include "exportfs.h" | |
| 6 | + | |
| 7 | +char Ebadfid[] = "Bad fid"; | |
| 8 | +char Enotdir[] = "Not a directory"; | |
| 9 | +char Edupfid[] = "Fid already in use"; | |
| 10 | +char Eopen[] = "Fid already opened"; | |
| 11 | +char Exmnt[] = "Cannot .. past mount point"; | |
| 12 | +char Emip[] = "Mount in progress"; | |
| 13 | +char Enopsmt[] = "Out of pseudo mount points"; | |
| 14 | +char Enomem[] = "No memory"; | |
| 15 | +char Eversion[] = "Bad 9P2000 version"; | |
| 16 | + | |
| 17 | +int iounit(int x) | |
| 18 | +{ | |
| 19 | + return 8192+IOHDRSZ; | |
| 20 | +} | |
| 21 | + | |
| 22 | +void* | |
| 23 | +emallocz(ulong n) | |
| 24 | +{ | |
| 25 | + void *v; | |
| 26 | + | |
| 27 | + v = mallocz(n, 1); | |
| 28 | + if(v == nil) | |
| 29 | + panic("out of memory"); | |
| 30 | + return v; | |
| 31 | +} | |
| 32 | + | |
| 33 | +ulong messagesize; | |
| 34 | + | |
| 35 | +void | |
| 36 | +Xversion(Fsrpc *t) | |
| 37 | +{ | |
| 38 | + Fcall rhdr; | |
| 39 | + | |
| 40 | + if(t->work.msize > messagesize) | |
| 41 | + t->work.msize = messagesize; | |
| 42 | + messagesize = t->work.msize; | |
| 43 | + if(strncmp(t->work.version, "9P2000", 6) != 0){ | |
| 44 | + reply(&t->work, &rhdr, Eversion); | |
| 45 | + return; | |
| 46 | + } | |
| 47 | + rhdr.version = "9P2000"; | |
| 48 | + rhdr.msize = t->work.msize; | |
| 49 | + reply(&t->work, &rhdr, 0); | |
| 50 | + t->busy = 0; | |
| 51 | +} | |
| 52 | + | |
| 53 | +void | |
| 54 | +Xauth(Fsrpc *t) | |
| 55 | +{ | |
| 56 | + Fcall rhdr; | |
| 57 | + | |
| 58 | + reply(&t->work, &rhdr, "exportfs: authentication not required"); | |
| 59 | + t->busy = 0; | |
| 60 | +} | |
| 61 | + | |
| 62 | +void | |
| 63 | +Xflush(Fsrpc *t) | |
| 64 | +{ | |
| 65 | + Fsrpc *w, *e; | |
| 66 | + Fcall rhdr; | |
| 67 | + | |
| 68 | + e = &Workq[Nr_workbufs]; | |
| 69 | + | |
| 70 | + for(w = Workq; w < e; w++) { | |
| 71 | + if(w->work.tag == t->work.oldtag) { | |
| 72 | + DEBUG(DFD, "\tQ busy %d pid %d can %d\n", w->busy, w->pid, w->canint); | |
| 73 | + if(w->busy && w->pid) { | |
| 74 | + w->flushtag = t->work.tag; | |
| 75 | + DEBUG(DFD, "\tset flushtag %d\n", t->work.tag); | |
| 76 | + // if(w->canint) | |
| 77 | + // postnote(PNPROC, w->pid, "flush"); | |
| 78 | + t->busy = 0; | |
| 79 | + return; | |
| 80 | + } | |
| 81 | + } | |
| 82 | + } | |
| 83 | + | |
| 84 | + reply(&t->work, &rhdr, 0); | |
| 85 | + DEBUG(DFD, "\tflush reply\n"); | |
| 86 | + t->busy = 0; | |
| 87 | +} | |
| 88 | + | |
| 89 | +void | |
| 90 | +Xattach(Fsrpc *t) | |
| 91 | +{ | |
| 92 | + int i, nfd; | |
| 93 | + Fcall rhdr; | |
| 94 | + Fid *f; | |
| 95 | + char buf[128]; | |
| 96 | + | |
| 97 | + f = newfid(t->work.fid); | |
| 98 | + if(f == 0) { | |
| 99 | + reply(&t->work, &rhdr, Ebadfid); | |
| 100 | + t->busy = 0; | |
| 101 | + return; | |
| 102 | + } | |
| 103 | + | |
| 104 | + if(srvfd >= 0){ | |
| 105 | +/* | |
| 106 | + if(psmpt == 0){ | |
| 107 | + Nomount: | |
| 108 | + reply(&t->work, &rhdr, Enopsmt); | |
| 109 | + t->busy = 0; | |
| 110 | + freefid(t->work.fid); | |
| 111 | + return; | |
| 112 | + } | |
| 113 | + for(i=0; i<Npsmpt; i++) | |
| 114 | + if(psmap[i] == 0) | |
| 115 | + break; | |
| 116 | + if(i >= Npsmpt) | |
| 117 | + goto Nomount; | |
| 118 | + sprint(buf, "%d", i); | |
| 119 | + f->f = file(psmpt, buf); | |
| 120 | + if(f->f == nil) | |
| 121 | + goto Nomount; | |
| 122 | + sprint(buf, "/mnt/exportfs/%d", i); | |
| 123 | + nfd = dup(srvfd, -1); | |
| 124 | + if(amount(nfd, buf, MREPL|MCREATE, t->work.aname) < 0){ | |
| 125 | + errstr(buf, sizeof buf); | |
| 126 | + reply(&t->work, &rhdr, buf); | |
| 127 | + t->busy = 0; | |
| 128 | + freefid(t->work.fid); | |
| 129 | + close(nfd); | |
| 130 | + return; | |
| 131 | + } | |
| 132 | + psmap[i] = 1; | |
| 133 | + f->mid = i; | |
| 134 | +*/ | |
| 135 | + }else{ | |
| 136 | + f->f = root; | |
| 137 | + f->f->ref++; | |
| 138 | + } | |
| 139 | + | |
| 140 | + rhdr.qid = f->f->qid; | |
| 141 | + reply(&t->work, &rhdr, 0); | |
| 142 | + t->busy = 0; | |
| 143 | +} | |
| 144 | + | |
| 145 | +Fid* | |
| 146 | +clonefid(Fid *f, int new) | |
| 147 | +{ | |
| 148 | + Fid *n; | |
| 149 | + | |
| 150 | + n = newfid(new); | |
| 151 | + if(n == 0) { | |
| 152 | + n = getfid(new); | |
| 153 | + if(n == 0) | |
| 154 | + fatal("inconsistent fids"); | |
| 155 | + if(n->fid >= 0) | |
| 156 | + close(n->fid); | |
| 157 | + freefid(new); | |
| 158 | + n = newfid(new); | |
| 159 | + if(n == 0) | |
| 160 | + fatal("inconsistent fids2"); | |
| 161 | + } | |
| 162 | + n->f = f->f; | |
| 163 | + n->f->ref++; | |
| 164 | + return n; | |
| 165 | +} | |
| 166 | + | |
| 167 | +void | |
| 168 | +Xwalk(Fsrpc *t) | |
| 169 | +{ | |
| 170 | + char err[ERRMAX], *e; | |
| 171 | + Fcall rhdr; | |
| 172 | + Fid *f, *nf; | |
| 173 | + File *wf; | |
| 174 | + int i; | |
| 175 | + | |
| 176 | + f = getfid(t->work.fid); | |
| 177 | + if(f == 0) { | |
| 178 | + reply(&t->work, &rhdr, Ebadfid); | |
| 179 | + t->busy = 0; | |
| 180 | + return; | |
| 181 | + } | |
| 182 | + | |
| 183 | + nf = nil; | |
| 184 | + if(t->work.newfid != t->work.fid){ | |
| 185 | + nf = clonefid(f, t->work.newfid); | |
| 186 | + f = nf; | |
| 187 | + } | |
| 188 | + | |
| 189 | + rhdr.nwqid = 0; | |
| 190 | + e = nil; | |
| 191 | + for(i=0; i<t->work.nwname; i++){ | |
| 192 | + if(i == MAXWELEM){ | |
| 193 | + e = "Too many path elements"; | |
| 194 | + break; | |
| 195 | + } | |
| 196 | + | |
| 197 | + if(strcmp(t->work.wname[i], "..") == 0) { | |
| 198 | + if(f->f->parent == nil) { | |
| 199 | + e = Exmnt; | |
| 200 | + break; | |
| 201 | + } | |
| 202 | + wf = f->f->parent; | |
| 203 | + wf->ref++; | |
| 204 | + goto Accept; | |
| 205 | + } | |
| 206 | + | |
| 207 | + wf = file(f->f, t->work.wname[i]); | |
| 208 | + if(wf == 0){ | |
| 209 | + errstr(err, sizeof err); | |
| 210 | + e = err; | |
| 211 | + break; | |
| 212 | + } | |
| 213 | + Accept: | |
| 214 | + freefile(f->f); | |
| 215 | + rhdr.wqid[rhdr.nwqid++] = wf->qid; | |
| 216 | + f->f = wf; | |
| 217 | + continue; | |
| 218 | + } | |
| 219 | + | |
| 220 | + if(nf!=nil && (e!=nil || rhdr.nwqid!=t->work.nwname)) | |
| 221 | + freefid(t->work.newfid); | |
| 222 | + if(rhdr.nwqid > 0) | |
| 223 | + e = nil; | |
| 224 | + reply(&t->work, &rhdr, e); | |
| 225 | + t->busy = 0; | |
| 226 | +} | |
| 227 | + | |
| 228 | +void | |
| 229 | +Xclunk(Fsrpc *t) | |
| 230 | +{ | |
| 231 | + Fcall rhdr; | |
| 232 | + Fid *f; | |
| 233 | + | |
| 234 | + f = getfid(t->work.fid); | |
| 235 | + if(f == 0) { | |
| 236 | + reply(&t->work, &rhdr, Ebadfid); | |
| 237 | + t->busy = 0; | |
| 238 | + return; | |
| 239 | + } | |
| 240 | + | |
| 241 | + if(f->fid >= 0) | |
| 242 | + close(f->fid); | |
| 243 | + | |
| 244 | + freefid(t->work.fid); | |
| 245 | + reply(&t->work, &rhdr, 0); | |
| 246 | + t->busy = 0; | |
| 247 | +} | |
| 248 | + | |
| 249 | +void | |
| 250 | +Xstat(Fsrpc *t) | |
| 251 | +{ | |
| 252 | + char err[ERRMAX], *path; | |
| 253 | + Fcall rhdr; | |
| 254 | + Fid *f; | |
| 255 | + Dir *d; | |
| 256 | + int s; | |
| 257 | + uchar *statbuf; | |
| 258 | + | |
| 259 | + f = getfid(t->work.fid); | |
| 260 | + if(f == 0) { | |
| 261 | + reply(&t->work, &rhdr, Ebadfid); | |
| 262 | + t->busy = 0; | |
| 263 | + return; | |
| 264 | + } | |
| 265 | + if(f->fid >= 0) | |
| 266 | + d = dirfstat(f->fid); | |
| 267 | + else { | |
| 268 | + path = makepath(f->f, ""); | |
| 269 | + d = dirstat(path); | |
| 270 | + free(path); | |
| 271 | + } | |
| 272 | + | |
| 273 | + if(d == nil) { | |
| 274 | + errstr(err, sizeof err); | |
| 275 | + reply(&t->work, &rhdr, err); | |
| 276 | + t->busy = 0; | |
| 277 | + return; | |
| 278 | + } | |
| 279 | + | |
| 280 | + d->qid.path = f->f->qidt->uniqpath; | |
| 281 | + s = sizeD2M(d); | |
| 282 | + statbuf = emallocz(s); | |
| 283 | + s = convD2M(d, statbuf, s); | |
| 284 | + free(d); | |
| 285 | + rhdr.nstat = s; | |
| 286 | + rhdr.stat = statbuf; | |
| 287 | + reply(&t->work, &rhdr, 0); | |
| 288 | + free(statbuf); | |
| 289 | + t->busy = 0; | |
| 290 | +} | |
| 291 | + | |
| 292 | +static int | |
| 293 | +getiounit(int fd) | |
| 294 | +{ | |
| 295 | + int n; | |
| 296 | + | |
| 297 | + n = iounit(fd); | |
| 298 | + if(n > messagesize-IOHDRSZ) | |
| 299 | + n = messagesize-IOHDRSZ; | |
| 300 | + return n; | |
| 301 | +} | |
| 302 | + | |
| 303 | +void | |
| 304 | +Xcreate(Fsrpc *t) | |
| 305 | +{ | |
| 306 | + char err[ERRMAX], *path; | |
| 307 | + Fcall rhdr; | |
| 308 | + Fid *f; | |
| 309 | + File *nf; | |
| 310 | + | |
| 311 | + f = getfid(t->work.fid); | |
| 312 | + if(f == 0) { | |
| 313 | + reply(&t->work, &rhdr, Ebadfid); | |
| 314 | + t->busy = 0; | |
| 315 | + return; | |
| 316 | + } | |
| 317 | + | |
| 318 | + | |
| 319 | + path = makepath(f->f, t->work.name); | |
| 320 | + f->fid = create(path, t->work.mode, t->work.perm); | |
| 321 | + free(path); | |
| 322 | + if(f->fid < 0) { | |
| 323 | + errstr(err, sizeof err); | |
| 324 | + reply(&t->work, &rhdr, err); | |
| 325 | + t->busy = 0; | |
| 326 | + return; | |
| 327 | + } | |
| 328 | + | |
| 329 | + nf = file(f->f, t->work.name); | |
| 330 | + if(nf == 0) { | |
| 331 | + errstr(err, sizeof err); | |
| 332 | + reply(&t->work, &rhdr, err); | |
| 333 | + t->busy = 0; | |
| 334 | + return; | |
| 335 | + } | |
| 336 | + | |
| 337 | + f->mode = t->work.mode; | |
| 338 | + freefile(f->f); | |
| 339 | + f->f = nf; | |
| 340 | + rhdr.qid = f->f->qid; | |
| 341 | + rhdr.iounit = getiounit(f->fid); | |
| 342 | + reply(&t->work, &rhdr, 0); | |
| 343 | + t->busy = 0; | |
| 344 | +} | |
| 345 | + | |
| 346 | +void | |
| 347 | +Xremove(Fsrpc *t) | |
| 348 | +{ | |
| 349 | + char err[ERRMAX], *path; | |
| 350 | + Fcall rhdr; | |
| 351 | + Fid *f; | |
| 352 | + | |
| 353 | + f = getfid(t->work.fid); | |
| 354 | + if(f == 0) { | |
| 355 | + reply(&t->work, &rhdr, Ebadfid); | |
| 356 | + t->busy = 0; | |
| 357 | + return; | |
| 358 | + } | |
| 359 | + | |
| 360 | + path = makepath(f->f, ""); | |
| 361 | + DEBUG(DFD, "\tremove: %s\n", path); | |
| 362 | + if(remove(path) < 0) { | |
| 363 | + free(path); | |
| 364 | + errstr(err, sizeof err); | |
| 365 | + reply(&t->work, &rhdr, err); | |
| 366 | + t->busy = 0; | |
| 367 | + return; | |
| 368 | + } | |
| 369 | + free(path); | |
| 370 | + | |
| 371 | + f->f->inval = 1; | |
| 372 | + if(f->fid >= 0) | |
| 373 | + close(f->fid); | |
| 374 | + freefid(t->work.fid); | |
| 375 | + | |
| 376 | + reply(&t->work, &rhdr, 0); | |
| 377 | + t->busy = 0; | |
| 378 | +} | |
| 379 | + | |
| 380 | +void | |
| 381 | +Xwstat(Fsrpc *t) | |
| 382 | +{ | |
| 383 | + char err[ERRMAX], *path; | |
| 384 | + Fcall rhdr; | |
| 385 | + Fid *f; | |
| 386 | + int s; | |
| 387 | + char *strings; | |
| 388 | + Dir d; | |
| 389 | + | |
| 390 | + f = getfid(t->work.fid); | |
| 391 | + if(f == 0) { | |
| 392 | + reply(&t->work, &rhdr, Ebadfid); | |
| 393 | + t->busy = 0; | |
| 394 | + return; | |
| 395 | + } | |
| 396 | + strings = emallocz(t->work.nstat); /* ample */ | |
| 397 | + if(convM2D(t->work.stat, t->work.nstat, &d, strings) < 0){ | |
| 398 | + rerrstr(err, sizeof err); | |
| 399 | + reply(&t->work, &rhdr, err); | |
| 400 | + t->busy = 0; | |
| 401 | + free(strings); | |
| 402 | + return; | |
| 403 | + } | |
| 404 | + | |
| 405 | + if(f->fid >= 0) | |
| 406 | + s = dirfwstat(f->fid, &d); | |
| 407 | + else { | |
| 408 | + path = makepath(f->f, ""); | |
| 409 | + s = dirwstat(path, &d); | |
| 410 | + free(path); | |
| 411 | + } | |
| 412 | + if(s < 0) { | |
| 413 | + rerrstr(err, sizeof err); | |
| 414 | + reply(&t->work, &rhdr, err); | |
| 415 | + } | |
| 416 | + else { | |
| 417 | + /* wstat may really be rename */ | |
| 418 | + if(strcmp(d.name, f->f->name)!=0 && strcmp(d.name, "")!=0){ | |
| 419 | + free(f->f->name); | |
| 420 | + f->f->name = estrdup(d.name); | |
| 421 | + } | |
| 422 | + reply(&t->work, &rhdr, 0); | |
| 423 | + } | |
| 424 | + free(strings); | |
| 425 | + t->busy = 0; | |
| 426 | +} | |
| 427 | + | |
| 428 | +void | |
| 429 | +slave(Fsrpc *f) | |
| 430 | +{ | |
| 431 | + Proc *p; | |
| 432 | + int pid; | |
| 433 | + static int nproc; | |
| 434 | + | |
| 435 | + for(;;) { | |
| 436 | + for(p = Proclist; p; p = p->next) { | |
| 437 | + if(p->busy == 0) { | |
| 438 | + f->pid = p->pid; | |
| 439 | + p->busy = 1; | |
| 440 | + pid = rendezvous(p->pid, (ulong)f); | |
| 441 | + if(pid != p->pid) | |
| 442 | + fatal("rendezvous sync fail"); | |
| 443 | + return; | |
| 444 | + } | |
| 445 | + } | |
| 446 | + | |
| 447 | + if(++nproc > MAXPROC) | |
| 448 | + fatal("too many procs"); | |
| 449 | + | |
| 450 | + pid = kproc("slave", blockingslave, nil); | |
| 451 | + DEBUG(DFD, "slave pid %d\n", pid); | |
| 452 | + if(pid == -1) | |
| 453 | + fatal("kproc"); | |
| 454 | + | |
| 455 | + p = malloc(sizeof(Proc)); | |
| 456 | + if(p == 0) | |
| 457 | + fatal("out of memory"); | |
| 458 | + | |
| 459 | + p->busy = 0; | |
| 460 | + p->pid = pid; | |
| 461 | + p->next = Proclist; | |
| 462 | + Proclist = p; | |
| 463 | + | |
| 464 | +DEBUG(DFD, "parent %d rendez\n", pid); | |
| 465 | + rendezvous(pid, (ulong)p); | |
| 466 | +DEBUG(DFD, "parent %d went\n", pid); | |
| 467 | + } | |
| 468 | +} | |
| 469 | + | |
| 470 | +void | |
| 471 | +blockingslave(void *x) | |
| 472 | +{ | |
| 473 | + Fsrpc *p; | |
| 474 | + Fcall rhdr; | |
| 475 | + Proc *m; | |
| 476 | + int pid; | |
| 477 | + | |
| 478 | + USED(x); | |
| 479 | + | |
| 480 | + notify(flushaction); | |
| 481 | + | |
| 482 | + pid = getpid(); | |
| 483 | + | |
| 484 | +DEBUG(DFD, "blockingslave %d rendez\n", pid); | |
| 485 | + m = (Proc*)rendezvous(pid, 0); | |
| 486 | +DEBUG(DFD, "blockingslave %d rendez got %p\n", pid, m); | |
| 487 | + | |
| 488 | + for(;;) { | |
| 489 | + p = (Fsrpc*)rendezvous(pid, pid); | |
| 490 | + if((int)p == ~0) /* Interrupted */ | |
| 491 | + continue; | |
| 492 | + | |
| 493 | + DEBUG(DFD, "\tslave: %d %F b %d p %d\n", pid, &p->work, p->busy, p->pid); | |
| 494 | + if(p->flushtag != NOTAG) | |
| 495 | + goto flushme; | |
| 496 | + | |
| 497 | + switch(p->work.type) { | |
| 498 | + case Tread: | |
| 499 | + slaveread(p); | |
| 500 | + break; | |
| 501 | + | |
| 502 | + case Twrite: | |
| 503 | + slavewrite(p); | |
| 504 | + break; | |
| 505 | + | |
| 506 | + case Topen: | |
| 507 | + slaveopen(p); | |
| 508 | + break; | |
| 509 | + | |
| 510 | + default: | |
| 511 | + reply(&p->work, &rhdr, "exportfs: slave type error"); | |
| 512 | + } | |
| 513 | + if(p->flushtag != NOTAG) { | |
| 514 | +flushme: | |
| 515 | + p->work.type = Tflush; | |
| 516 | + p->work.tag = p->flushtag; | |
| 517 | + reply(&p->work, &rhdr, 0); | |
| 518 | + } | |
| 519 | + p->busy = 0; | |
| 520 | + m->busy = 0; | |
| 521 | + } | |
| 522 | +} | |
| 523 | + | |
| 524 | +int | |
| 525 | +openmount(int sfd) | |
| 526 | +{ | |
| 527 | + werrstr("openmount not implemented"); | |
| 528 | + return -1; | |
| 529 | +} | |
| 530 | + | |
| 531 | +void | |
| 532 | +slaveopen(Fsrpc *p) | |
| 533 | +{ | |
| 534 | + char err[ERRMAX], *path; | |
| 535 | + Fcall *work, rhdr; | |
| 536 | + Fid *f; | |
| 537 | + Dir *d; | |
| 538 | + | |
| 539 | + work = &p->work; | |
| 540 | + | |
| 541 | + f = getfid(work->fid); | |
| 542 | + if(f == 0) { | |
| 543 | + reply(work, &rhdr, Ebadfid); | |
| 544 | + return; | |
| 545 | + } | |
| 546 | + if(f->fid >= 0) { | |
| 547 | + close(f->fid); | |
| 548 | + f->fid = -1; | |
| 549 | + } | |
| 550 | + | |
| 551 | + path = makepath(f->f, ""); | |
| 552 | + DEBUG(DFD, "\topen: %s %d\n", path, work->mode); | |
| 553 | + | |
| 554 | + p->canint = 1; | |
| 555 | + if(p->flushtag != NOTAG){ | |
| 556 | + free(path); | |
| 557 | + return; | |
| 558 | + } | |
| 559 | + /* There is a race here I ignore because there are no locks */ | |
| 560 | + f->fid = open(path, work->mode); | |
| 561 | + free(path); | |
| 562 | + p->canint = 0; | |
| 563 | + if(f->fid < 0 || (d = dirfstat(f->fid)) == nil) { | |
| 564 | + Error: | |
| 565 | + errstr(err, sizeof err); | |
| 566 | + reply(work, &rhdr, err); | |
| 567 | + return; | |
| 568 | + } | |
| 569 | + f->f->qid = d->qid; | |
| 570 | + free(d); | |
| 571 | + if(f->f->qid.type & QTMOUNT){ /* fork new exportfs for this */ | |
| 572 | + f->fid = openmount(f->fid); | |
| 573 | + if(f->fid < 0) | |
| 574 | + goto Error; | |
| 575 | + } | |
| 576 | + | |
| 577 | + DEBUG(DFD, "\topen: fd %d\n", f->fid); | |
| 578 | + f->mode = work->mode; | |
| 579 | + rhdr.iounit = getiounit(f->fid); | |
| 580 | + rhdr.qid = f->f->qid; | |
| 581 | + reply(work, &rhdr, 0); | |
| 582 | +} | |
| 583 | + | |
| 584 | +void | |
| 585 | +slaveread(Fsrpc *p) | |
| 586 | +{ | |
| 587 | + Fid *f; | |
| 588 | + int n, r; | |
| 589 | + Fcall *work, rhdr; | |
| 590 | + char *data, err[ERRMAX]; | |
| 591 | + | |
| 592 | + work = &p->work; | |
| 593 | + | |
| 594 | + f = getfid(work->fid); | |
| 595 | + if(f == 0) { | |
| 596 | + reply(work, &rhdr, Ebadfid); | |
| 597 | + return; | |
| 598 | + } | |
| 599 | + | |
| 600 | + n = (work->count > messagesize-IOHDRSZ) ? messagesize-IOHDRSZ : work->count; | |
| 601 | + p->canint = 1; | |
| 602 | + if(p->flushtag != NOTAG) | |
| 603 | + return; | |
| 604 | + data = malloc(n); | |
| 605 | + if(data == nil) | |
| 606 | + fatal(Enomem); | |
| 607 | + | |
| 608 | + /* can't just call pread, since directories must update the offset */ | |
| 609 | + r = pread(f->fid, data, n, work->offset); | |
| 610 | + p->canint = 0; | |
| 611 | + if(r < 0) { | |
| 612 | + free(data); | |
| 613 | + errstr(err, sizeof err); | |
| 614 | + reply(work, &rhdr, err); | |
| 615 | + return; | |
| 616 | + } | |
| 617 | + | |
| 618 | + DEBUG(DFD, "\tread: fd=%d %d bytes\n", f->fid, r); | |
| 619 | + | |
| 620 | + rhdr.data = data; | |
| 621 | + rhdr.count = r; | |
| 622 | + reply(work, &rhdr, 0); | |
| 623 | + free(data); | |
| 624 | +} | |
| 625 | + | |
| 626 | +void | |
| 627 | +slavewrite(Fsrpc *p) | |
| 628 | +{ | |
| 629 | + char err[ERRMAX]; | |
| 630 | + Fcall *work, rhdr; | |
| 631 | + Fid *f; | |
| 632 | + int n; | |
| 633 | + | |
| 634 | + work = &p->work; | |
| 635 | + | |
| 636 | + f = getfid(work->fid); | |
| 637 | + if(f == 0) { | |
| 638 | + reply(work, &rhdr, Ebadfid); | |
| 639 | + return; | |
| 640 | + } | |
| 641 | + | |
| 642 | + n = (work->count > messagesize-IOHDRSZ) ? messagesize-IOHDRSZ : work->count; | |
| 643 | + p->canint = 1; | |
| 644 | + if(p->flushtag != NOTAG) | |
| 645 | + return; | |
| 646 | + n = pwrite(f->fid, work->data, n, work->offset); | |
| 647 | + p->canint = 0; | |
| 648 | + if(n < 0) { | |
| 649 | + errstr(err, sizeof err); | |
| 650 | + reply(work, &rhdr, err); | |
| 651 | + return; | |
| 652 | + } | |
| 653 | + | |
| 654 | + DEBUG(DFD, "\twrite: %d bytes fd=%d\n", n, f->fid); | |
| 655 | + | |
| 656 | + rhdr.count = n; | |
| 657 | + reply(work, &rhdr, 0); | |
| 658 | +} | |
| 659 | + | |
| 660 | +void | |
| 661 | +reopen(Fid *f) | |
| 662 | +{ | |
| 663 | + USED(f); | |
| 664 | + fatal("reopen"); | |
| 665 | +} | |
| 666 | + | |
| 667 | +void | |
| 668 | +flushaction(void *a, char *cause) | |
| 669 | +{ | |
| 670 | + USED(a); | |
| 671 | + if(strncmp(cause, "sys:", 4) == 0 && !strstr(cause, "pipe")) { | |
| 672 | + fprint(2, "exportsrv: note: %s\n", cause); | |
| 673 | + exits("noted"); | |
| 674 | + } | |
| 675 | + if(strncmp(cause, "kill", 4) == 0) | |
| 676 | + noted(NDFLT); | |
| 677 | + | |
| 678 | + noted(NCONT); | |
| 679 | +} | |
| @@ -0,0 +1,11 @@ | ||
| 1 | +<$DSRC/mkfile-$CONF | |
| 2 | +TARG=libexportfs.$L | |
| 3 | + | |
| 4 | +OFILES=\ | |
| 5 | + exportfs.$O\ | |
| 6 | + exportsrv.$O | |
| 7 | + | |
| 8 | +HFILES=\ | |
| 9 | + exportfs.h | |
| 10 | + | |
| 11 | +<$DSRC/mklib-$CONF | |
| @@ -0,0 +1,23 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | +#include <draw.h> | |
| 4 | +#include <memdraw.h> | |
| 5 | + | |
| 6 | +Memimage* | |
| 7 | +allocmemimage(Rectangle r, ulong chan) | |
| 8 | +{ | |
| 9 | + return _allocmemimage(r, chan); | |
| 10 | +} | |
| 11 | + | |
| 12 | +void | |
| 13 | +freememimage(Memimage *i) | |
| 14 | +{ | |
| 15 | + _freememimage(i); | |
| 16 | +} | |
| 17 | + | |
| 18 | +void | |
| 19 | +memfillcolor(Memimage *i, ulong val) | |
| 20 | +{ | |
| 21 | + _memfillcolor(i, val); | |
| 22 | +} | |
| 23 | + | |
| @@ -0,0 +1,10 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | +#include <draw.h> | |
| 4 | +#include <memdraw.h> | |
| 5 | + | |
| 6 | +int | |
| 7 | +cloadmemimage(Memimage *i, Rectangle r, uchar *data, int ndata) | |
| 8 | +{ | |
| 9 | + return _cloadmemimage(i, r, data, ndata); | |
| 10 | +} | |
| @@ -0,0 +1,22 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | +#include <draw.h> | |
| 4 | +#include <memdraw.h> | |
| 5 | + | |
| 6 | +void | |
| 7 | +memimagedraw(Memimage *dst, Rectangle r, Memimage *src, Point sp, Memimage *mask, Point mp, int op) | |
| 8 | +{ | |
| 9 | + _memimagedraw(_memimagedrawsetup(dst, r, src, sp, mask, mp, op)); | |
| 10 | +} | |
| 11 | + | |
| 12 | +ulong | |
| 13 | +pixelbits(Memimage *m, Point p) | |
| 14 | +{ | |
| 15 | + return _pixelbits(m, p); | |
| 16 | +} | |
| 17 | + | |
| 18 | +void | |
| 19 | +memimageinit(void) | |
| 20 | +{ | |
| 21 | + _memimageinit(); | |
| 22 | +} | |
| @@ -0,0 +1,10 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | +#include <draw.h> | |
| 4 | +#include <memdraw.h> | |
| 5 | + | |
| 6 | +int | |
| 7 | +loadmemimage(Memimage *i, Rectangle r, uchar *data, int ndata) | |
| 8 | +{ | |
| 9 | + return _loadmemimage(i, r, data, ndata); | |
| 10 | +} | |
| @@ -0,0 +1,14 @@ | ||
| 1 | +<$DSRC/mkfile-$CONF | |
| 2 | +TARG=libgui.$L | |
| 3 | + | |
| 4 | +OFILES=\ | |
| 5 | + alloc.$O\ | |
| 6 | + cload.$O\ | |
| 7 | + draw.$O\ | |
| 8 | + load.$O\ | |
| 9 | + screen.$O\ | |
| 10 | + wstrtoutf.$O | |
| 11 | + | |
| 12 | +HFILES=\ | |
| 13 | + | |
| 14 | +<$DSRC/mklib-$CONF | |
| @@ -0,0 +1,642 @@ | ||
| 1 | +#include <windows.h> | |
| 2 | +// #include "winduhz.h" | |
| 3 | + | |
| 4 | +#undef Rectangle | |
| 5 | +#define Rectangle _Rectangle | |
| 6 | + | |
| 7 | +#include <u.h> | |
| 8 | +#include <libc.h> | |
| 9 | +#include <dat.h> | |
| 10 | +#include <draw.h> | |
| 11 | +#include <memdraw.h> | |
| 12 | +#include "error.h" | |
| 13 | +#include "screen.h" | |
| 14 | +#include "keyboard.h" | |
| 15 | +#include "fns.h" | |
| 16 | + | |
| 17 | +Memimage *gscreen; | |
| 18 | +Screeninfo screen; | |
| 19 | + | |
| 20 | +extern int mousequeue; | |
| 21 | +static int depth; | |
| 22 | + | |
| 23 | +static HINSTANCE inst; | |
| 24 | +static HWND window; | |
| 25 | +static HPALETTE palette; | |
| 26 | +static LOGPALETTE *logpal; | |
| 27 | +static Lock gdilock; | |
| 28 | +static BITMAPINFO *bmi; | |
| 29 | +static HCURSOR hcursor; | |
| 30 | + | |
| 31 | +static void winproc(void *); | |
| 32 | +static LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam); | |
| 33 | +static void paletteinit(void); | |
| 34 | +static void bmiinit(void); | |
| 35 | +static void screenload2(Rectangle r, int ldepth, uchar *p, Point pt, int step); | |
| 36 | + | |
| 37 | +static int readybit; | |
| 38 | +static Rendez rend; | |
| 39 | + | |
| 40 | +Point ZP; | |
| 41 | + | |
| 42 | +static | |
| 43 | +isready(void*a) | |
| 44 | +{ | |
| 45 | + return readybit; | |
| 46 | +} | |
| 47 | + | |
| 48 | +void | |
| 49 | +screeninit(void) | |
| 50 | +{ | |
| 51 | + int fmt; | |
| 52 | + int dx, dy; | |
| 53 | + | |
| 54 | + memimageinit(); | |
| 55 | + if(depth == 0) | |
| 56 | + depth = GetDeviceCaps(GetDC(NULL), BITSPIXEL); | |
| 57 | + switch(depth){ | |
| 58 | + case 32: | |
| 59 | + screen.dibtype = DIB_RGB_COLORS; | |
| 60 | + screen.depth = 32; | |
| 61 | + fmt = XRGB32; | |
| 62 | + break; | |
| 63 | + case 24: | |
| 64 | + screen.dibtype = DIB_RGB_COLORS; | |
| 65 | + screen.depth = 24; | |
| 66 | + fmt = RGB24; | |
| 67 | + break; | |
| 68 | + case 16: | |
| 69 | + screen.dibtype = DIB_RGB_COLORS; | |
| 70 | + screen.depth = 16; | |
| 71 | + fmt = RGB15; /* [sic] */ | |
| 72 | + break; | |
| 73 | + case 8: | |
| 74 | + default: | |
| 75 | + screen.dibtype = DIB_PAL_COLORS; | |
| 76 | + screen.depth = 8; | |
| 77 | + depth = 8; | |
| 78 | + fmt = CMAP8; | |
| 79 | + break; | |
| 80 | + } | |
| 81 | + dx = GetDeviceCaps(GetDC(NULL), HORZRES); | |
| 82 | + dy = GetDeviceCaps(GetDC(NULL), VERTRES); | |
| 83 | + | |
| 84 | + gscreen = allocmemimage(Rect(0,0,dx,dy), fmt); | |
| 85 | + kproc("winscreen", winproc, 0); | |
| 86 | + sleep(&rend, isready, 0); | |
| 87 | +} | |
| 88 | + | |
| 89 | +uchar* | |
| 90 | +attachscreen(Rectangle *r, ulong *chan, int *depth, int *width, int *softscreen, void **X) | |
| 91 | +{ | |
| 92 | + *r = gscreen->r; | |
| 93 | + *chan = gscreen->chan; | |
| 94 | + *depth = gscreen->depth; | |
| 95 | + *width = gscreen->width; | |
| 96 | + *softscreen = 1; | |
| 97 | + | |
| 98 | + return gscreen->data->bdata; | |
| 99 | +} | |
| 100 | + | |
| 101 | +void | |
| 102 | +flushmemscreen(Rectangle r) | |
| 103 | +{ | |
| 104 | + screenload(r, gscreen->depth, byteaddr(gscreen, ZP), ZP, | |
| 105 | + gscreen->width*sizeof(ulong)); | |
| 106 | +// Sleep(100); | |
| 107 | +} | |
| 108 | + | |
| 109 | +void | |
| 110 | +screenload(Rectangle r, int depth, uchar *p, Point pt, int step) | |
| 111 | +{ | |
| 112 | + int dx, dy, delx; | |
| 113 | + HDC hdc; | |
| 114 | + RECT winr; | |
| 115 | + | |
| 116 | + if(depth != gscreen->depth) | |
| 117 | + panic("screenload: bad ldepth"); | |
| 118 | + | |
| 119 | + /* | |
| 120 | + * Sometimes we do get rectangles that are off the | |
| 121 | + * screen to the negative axes, for example, when | |
| 122 | + * dragging around a window border in a Move operation. | |
| 123 | + */ | |
| 124 | + if(rectclip(&r, gscreen->r) == 0) | |
| 125 | + return; | |
| 126 | + | |
| 127 | + if(step&3 != 0 || ((pt.x*depth)%32) != 0 || (ulong)p&3 != 0) | |
| 128 | + panic("screenload: bad params %d %d %ux", step, pt.x, p); | |
| 129 | + dx = r.max.x - r.min.x; | |
| 130 | + dy = r.max.y - r.min.y; | |
| 131 | + | |
| 132 | + if(dx <= 0 || dy <= 0) | |
| 133 | + return; | |
| 134 | + | |
| 135 | + if(depth == 24) | |
| 136 | + delx = r.min.x % 4; | |
| 137 | + else | |
| 138 | + delx = r.min.x & (31/depth); | |
| 139 | + | |
| 140 | + p += (r.min.y-pt.y)*step; | |
| 141 | + p += ((r.min.x-delx-pt.x)*depth)>>3; | |
| 142 | + | |
| 143 | + if(GetWindowRect(window, &winr)==0) | |
| 144 | + return; | |
| 145 | + if(rectclip(&r, Rect(0, 0, winr.right-winr.left, winr.bottom-winr.top))==0) | |
| 146 | + return; | |
| 147 | + | |
| 148 | + lock(&gdilock); | |
| 149 | + | |
| 150 | + hdc = GetDC(window); | |
| 151 | + SelectPalette(hdc, palette, 0); | |
| 152 | + RealizePalette(hdc); | |
| 153 | + | |
| 154 | +//FillRect(hdc,(void*)&r, GetStockObject(BLACK_BRUSH)); | |
| 155 | +//GdiFlush(); | |
| 156 | +//Sleep(100); | |
| 157 | + | |
| 158 | + bmi->bmiHeader.biWidth = (step*8)/depth; | |
| 159 | + bmi->bmiHeader.biHeight = -dy; /* - => origin upper left */ | |
| 160 | + | |
| 161 | + StretchDIBits(hdc, r.min.x, r.min.y, dx, dy, | |
| 162 | + delx, 0, dx, dy, p, bmi, screen.dibtype, SRCCOPY); | |
| 163 | + | |
| 164 | + ReleaseDC(window, hdc); | |
| 165 | + | |
| 166 | + GdiFlush(); | |
| 167 | + | |
| 168 | + unlock(&gdilock); | |
| 169 | +} | |
| 170 | + | |
| 171 | +static void | |
| 172 | +winproc(void *a) | |
| 173 | +{ | |
| 174 | + WNDCLASS wc; | |
| 175 | + MSG msg; | |
| 176 | + | |
| 177 | + inst = GetModuleHandle(NULL); | |
| 178 | + | |
| 179 | + paletteinit(); | |
| 180 | + bmiinit(); | |
| 181 | + terminit(); | |
| 182 | + | |
| 183 | + wc.style = 0; | |
| 184 | + wc.lpfnWndProc = WindowProc; | |
| 185 | + wc.cbClsExtra = 0; | |
| 186 | + wc.cbWndExtra = 0; | |
| 187 | + wc.hInstance = inst; | |
| 188 | + wc.hIcon = LoadIcon(inst, NULL); | |
| 189 | + wc.hCursor = LoadCursor(NULL, IDC_ARROW); | |
| 190 | + wc.hbrBackground = GetStockObject(WHITE_BRUSH); | |
| 191 | + wc.lpszMenuName = 0; | |
| 192 | + wc.lpszClassName = "9pmgraphics"; | |
| 193 | + RegisterClass(&wc); | |
| 194 | + | |
| 195 | + window = CreateWindowEx( | |
| 196 | + 0, /* extended style */ | |
| 197 | + "9pmgraphics", /* class */ | |
| 198 | + "drawterm screen", /* caption */ | |
| 199 | + WS_OVERLAPPEDWINDOW, /* style */ | |
| 200 | + CW_USEDEFAULT, /* init. x pos */ | |
| 201 | + CW_USEDEFAULT, /* init. y pos */ | |
| 202 | + CW_USEDEFAULT, /* init. x size */ | |
| 203 | + CW_USEDEFAULT, /* init. y size */ | |
| 204 | + NULL, /* parent window (actually owner window for overlapped)*/ | |
| 205 | + NULL, /* menu handle */ | |
| 206 | + inst, /* program handle */ | |
| 207 | + NULL /* create parms */ | |
| 208 | + ); | |
| 209 | + | |
| 210 | + if(window == nil) | |
| 211 | + panic("can't make window\n"); | |
| 212 | + | |
| 213 | + ShowWindow(window, SW_SHOWDEFAULT); | |
| 214 | + UpdateWindow(window); | |
| 215 | + | |
| 216 | + readybit = 1; | |
| 217 | + wakeup(&rend); | |
| 218 | + | |
| 219 | + screen.reshaped = 0; | |
| 220 | + | |
| 221 | + while(GetMessage(&msg, NULL, 0, 0)) { | |
| 222 | + TranslateMessage(&msg); | |
| 223 | + DispatchMessage(&msg); | |
| 224 | + } | |
| 225 | +// MessageBox(0, "winproc", "exits", MB_OK); | |
| 226 | + ExitProcess(0); | |
| 227 | +} | |
| 228 | + | |
| 229 | +int | |
| 230 | +col(int v, int n) | |
| 231 | +{ | |
| 232 | + int i, c; | |
| 233 | + | |
| 234 | + c = 0; | |
| 235 | + for(i = 0; i < 8; i += n) | |
| 236 | + c |= v << (16-(n+i)); | |
| 237 | + return c >> 8; | |
| 238 | +} | |
| 239 | + | |
| 240 | + | |
| 241 | +void | |
| 242 | +paletteinit(void) | |
| 243 | +{ | |
| 244 | + PALETTEENTRY *pal; | |
| 245 | + int r, g, b, cr, cg, cb, v; | |
| 246 | + int num, den; | |
| 247 | + int i, j; | |
| 248 | + | |
| 249 | + logpal = mallocz(sizeof(LOGPALETTE) + 256*sizeof(PALETTEENTRY), 1); | |
| 250 | + if(logpal == nil) | |
| 251 | + panic("out of memory"); | |
| 252 | + logpal->palVersion = 0x300; | |
| 253 | + logpal->palNumEntries = 256; | |
| 254 | + pal = logpal->palPalEntry; | |
| 255 | + | |
| 256 | + for(r=0,i=0; r<4; r++) { | |
| 257 | + for(v=0; v<4; v++,i+=16){ | |
| 258 | + for(g=0,j=v-r; g<4; g++) { | |
| 259 | + for(b=0; b<4; b++,j++){ | |
| 260 | + den=r; | |
| 261 | + if(g>den) | |
| 262 | + den=g; | |
| 263 | + if(b>den) | |
| 264 | + den=b; | |
| 265 | + /* divide check -- pick grey shades */ | |
| 266 | + if(den==0) | |
| 267 | + cr=cg=cb=v*17; | |
| 268 | + else{ | |
| 269 | + num=17*(4*den+v); | |
| 270 | + cr=r*num/den; | |
| 271 | + cg=g*num/den; | |
| 272 | + cb=b*num/den; | |
| 273 | + } | |
| 274 | + pal[i+(j&15)].peRed = cr; | |
| 275 | + pal[i+(j&15)].peGreen = cg; | |
| 276 | + pal[i+(j&15)].peBlue = cb; | |
| 277 | + pal[i+(j&15)].peFlags = 0; | |
| 278 | + } | |
| 279 | + } | |
| 280 | + } | |
| 281 | + } | |
| 282 | + palette = CreatePalette(logpal); | |
| 283 | +} | |
| 284 | + | |
| 285 | + | |
| 286 | +void | |
| 287 | +getcolor(ulong i, ulong *r, ulong *g, ulong *b) | |
| 288 | +{ | |
| 289 | + PALETTEENTRY *pal; | |
| 290 | + | |
| 291 | + pal = logpal->palPalEntry; | |
| 292 | + *r = pal[i].peRed; | |
| 293 | + *g = pal[i].peGreen; | |
| 294 | + *b = pal[i].peBlue; | |
| 295 | +} | |
| 296 | + | |
| 297 | +void | |
| 298 | +bmiinit(void) | |
| 299 | +{ | |
| 300 | + ushort *p; | |
| 301 | + int i; | |
| 302 | + | |
| 303 | + bmi = mallocz(sizeof(BITMAPINFOHEADER) + 256*sizeof(RGBQUAD), 1); | |
| 304 | + if(bmi == 0) | |
| 305 | + panic("out of memory"); | |
| 306 | + bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); | |
| 307 | + bmi->bmiHeader.biWidth = 0; | |
| 308 | + bmi->bmiHeader.biHeight = 0; /* - => origin upper left */ | |
| 309 | + bmi->bmiHeader.biPlanes = 1; | |
| 310 | + bmi->bmiHeader.biBitCount = depth; | |
| 311 | + bmi->bmiHeader.biCompression = BI_RGB; | |
| 312 | + bmi->bmiHeader.biSizeImage = 0; | |
| 313 | + bmi->bmiHeader.biXPelsPerMeter = 0; | |
| 314 | + bmi->bmiHeader.biYPelsPerMeter = 0; | |
| 315 | + bmi->bmiHeader.biClrUsed = 0; | |
| 316 | + bmi->bmiHeader.biClrImportant = 0; /* number of important colors: 0 means all */ | |
| 317 | + | |
| 318 | + p = (ushort*)bmi->bmiColors; | |
| 319 | + for(i = 0; i < 256; i++) | |
| 320 | + p[i] = i; | |
| 321 | +} | |
| 322 | + | |
| 323 | +LRESULT CALLBACK | |
| 324 | +WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) | |
| 325 | +{ | |
| 326 | + PAINTSTRUCT paint; | |
| 327 | + HDC hdc; | |
| 328 | + LONG x, y, b; | |
| 329 | + int i; | |
| 330 | + Rectangle r; | |
| 331 | + | |
| 332 | + switch(msg) { | |
| 333 | + case WM_CREATE: | |
| 334 | + break; | |
| 335 | + case WM_SETCURSOR: | |
| 336 | + /* User set */ | |
| 337 | + if(hcursor != NULL) { | |
| 338 | + SetCursor(hcursor); | |
| 339 | + return 1; | |
| 340 | + } | |
| 341 | + return DefWindowProc(hwnd, msg, wparam, lparam); | |
| 342 | + case WM_MOUSEMOVE: | |
| 343 | + case WM_LBUTTONUP: | |
| 344 | + case WM_MBUTTONUP: | |
| 345 | + case WM_RBUTTONUP: | |
| 346 | + case WM_LBUTTONDOWN: | |
| 347 | + case WM_MBUTTONDOWN: | |
| 348 | + case WM_RBUTTONDOWN: | |
| 349 | + x = LOWORD(lparam); | |
| 350 | + y = HIWORD(lparam); | |
| 351 | + b = 0; | |
| 352 | + if(wparam & MK_LBUTTON) | |
| 353 | + b = 1; | |
| 354 | + if(wparam & MK_MBUTTON) | |
| 355 | + b |= 2; | |
| 356 | + if(wparam & MK_RBUTTON) { | |
| 357 | + if(wparam & MK_SHIFT) | |
| 358 | + b |= 2; | |
| 359 | + else | |
| 360 | + b |= 4; | |
| 361 | + } | |
| 362 | + lock(&mouse.lk); | |
| 363 | + i = mouse.wi; | |
| 364 | + if(mousequeue) { | |
| 365 | + if(i == mouse.ri || mouse.lastb != b || mouse.trans) { | |
| 366 | + mouse.wi = (i+1)%Mousequeue; | |
| 367 | + if(mouse.wi == mouse.ri) | |
| 368 | + mouse.ri = (mouse.ri+1)%Mousequeue; | |
| 369 | + mouse.trans = mouse.lastb != b; | |
| 370 | + } else { | |
| 371 | + i = (i-1+Mousequeue)%Mousequeue; | |
| 372 | + } | |
| 373 | + } else { | |
| 374 | + mouse.wi = (i+1)%Mousequeue; | |
| 375 | + mouse.ri = i; | |
| 376 | + } | |
| 377 | + mouse.queue[i].xy.x = x; | |
| 378 | + mouse.queue[i].xy.y = y; | |
| 379 | + mouse.queue[i].buttons = b; | |
| 380 | + mouse.queue[i].msec = ticks(); | |
| 381 | + mouse.lastb = b; | |
| 382 | + unlock(&mouse.lk); | |
| 383 | + wakeup(&mouse.r); | |
| 384 | + break; | |
| 385 | + | |
| 386 | + case WM_CHAR: | |
| 387 | + /* repeat count is lparam & 0xf */ | |
| 388 | + switch(wparam){ | |
| 389 | + case '\n': | |
| 390 | + wparam = '\r'; | |
| 391 | + break; | |
| 392 | + case '\r': | |
| 393 | + wparam = '\n'; | |
| 394 | + break; | |
| 395 | + } | |
| 396 | + kbdputc(kbdq, wparam); | |
| 397 | + break; | |
| 398 | + | |
| 399 | + case WM_SYSKEYUP: | |
| 400 | + break; | |
| 401 | + case WM_SYSKEYDOWN: | |
| 402 | + case WM_KEYDOWN: | |
| 403 | + switch(wparam) { | |
| 404 | + case VK_MENU: | |
| 405 | + kbdputc(kbdq, Kalt); | |
| 406 | + break; | |
| 407 | + case VK_INSERT: | |
| 408 | + kbdputc(kbdq, Kins); | |
| 409 | + break; | |
| 410 | + case VK_DELETE: | |
| 411 | +// kbdputc(kbdq, Kdel); | |
| 412 | + kbdputc(kbdq, 0x7f); // should have Kdel in keyboard.h | |
| 413 | + break; | |
| 414 | + case VK_UP: | |
| 415 | + kbdputc(kbdq, Kup); | |
| 416 | + break; | |
| 417 | + case VK_DOWN: | |
| 418 | + kbdputc(kbdq, Kdown); | |
| 419 | + break; | |
| 420 | + case VK_LEFT: | |
| 421 | + kbdputc(kbdq, Kleft); | |
| 422 | + break; | |
| 423 | + case VK_RIGHT: | |
| 424 | + kbdputc(kbdq, Kright); | |
| 425 | + break; | |
| 426 | + } | |
| 427 | + break; | |
| 428 | + | |
| 429 | + case WM_CLOSE: | |
| 430 | + DestroyWindow(hwnd); | |
| 431 | + break; | |
| 432 | + | |
| 433 | + case WM_DESTROY: | |
| 434 | + PostQuitMessage(0); | |
| 435 | + break; | |
| 436 | + | |
| 437 | + case WM_PALETTECHANGED: | |
| 438 | + if((HWND)wparam == hwnd) | |
| 439 | + break; | |
| 440 | + /* fall through */ | |
| 441 | + case WM_QUERYNEWPALETTE: | |
| 442 | + hdc = GetDC(hwnd); | |
| 443 | + SelectPalette(hdc, palette, 0); | |
| 444 | + if(RealizePalette(hdc) != 0) | |
| 445 | + InvalidateRect(hwnd, nil, 0); | |
| 446 | + ReleaseDC(hwnd, hdc); | |
| 447 | + break; | |
| 448 | + | |
| 449 | + case WM_PAINT: | |
| 450 | + hdc = BeginPaint(hwnd, &paint); | |
| 451 | + r.min.x = paint.rcPaint.left; | |
| 452 | + r.min.y = paint.rcPaint.top; | |
| 453 | + r.max.x = paint.rcPaint.right; | |
| 454 | + r.max.y = paint.rcPaint.bottom; | |
| 455 | + flushmemscreen(r); | |
| 456 | + EndPaint(hwnd, &paint); | |
| 457 | + break; | |
| 458 | + case WM_COMMAND: | |
| 459 | + case WM_SETFOCUS: | |
| 460 | + case WM_DEVMODECHANGE: | |
| 461 | + case WM_WININICHANGE: | |
| 462 | + case WM_INITMENU: | |
| 463 | + default: | |
| 464 | + return DefWindowProc(hwnd, msg, wparam, lparam); | |
| 465 | + } | |
| 466 | + return 0; | |
| 467 | +} | |
| 468 | + | |
| 469 | +void | |
| 470 | +mouseset(Point xy) | |
| 471 | +{ | |
| 472 | + POINT pt; | |
| 473 | + | |
| 474 | + pt.x = xy.x; | |
| 475 | + pt.y = xy.y; | |
| 476 | + MapWindowPoints(window, 0, &pt, 1); | |
| 477 | + SetCursorPos(pt.x, pt.y); | |
| 478 | +} | |
| 479 | + | |
| 480 | +void | |
| 481 | +setcursor(void) | |
| 482 | +{ | |
| 483 | + HCURSOR nh; | |
| 484 | + int x, y, h, w; | |
| 485 | + uchar *sp, *cp; | |
| 486 | + uchar *and, *xor; | |
| 487 | + | |
| 488 | + h = GetSystemMetrics(SM_CYCURSOR); | |
| 489 | + w = (GetSystemMetrics(SM_CXCURSOR)+7)/8; | |
| 490 | + | |
| 491 | + and = mallocz(h*w, 1); | |
| 492 | + memset(and, 0xff, h*w); | |
| 493 | + xor = mallocz(h*w, 1); | |
| 494 | + | |
| 495 | + lock(&cursor.lk); | |
| 496 | + for(y=0,sp=cursor.set,cp=cursor.clr; y<16; y++) { | |
| 497 | + for(x=0; x<2; x++) { | |
| 498 | + and[y*w+x] = ~(*sp|*cp); | |
| 499 | + xor[y*w+x] = ~*sp & *cp; | |
| 500 | + cp++; | |
| 501 | + sp++; | |
| 502 | + } | |
| 503 | + } | |
| 504 | + nh = CreateCursor(inst, -cursor.offset.x, -cursor.offset.y, | |
| 505 | + GetSystemMetrics(SM_CXCURSOR), h, | |
| 506 | + and, xor); | |
| 507 | + if(nh != NULL) { | |
| 508 | + SetCursor(nh); | |
| 509 | + if(hcursor != NULL) | |
| 510 | + DestroyCursor(hcursor); | |
| 511 | + hcursor = nh; | |
| 512 | + } | |
| 513 | + unlock(&cursor.lk); | |
| 514 | + | |
| 515 | + free(and); | |
| 516 | + free(xor); | |
| 517 | + | |
| 518 | + PostMessage(window, WM_SETCURSOR, (int)window, 0); | |
| 519 | +} | |
| 520 | + | |
| 521 | +void | |
| 522 | +cursorarrow(void) | |
| 523 | +{ | |
| 524 | + if(hcursor != 0) { | |
| 525 | + DestroyCursor(hcursor); | |
| 526 | + hcursor = 0; | |
| 527 | + } | |
| 528 | + SetCursor(LoadCursor(0, IDC_ARROW)); | |
| 529 | + PostMessage(window, WM_SETCURSOR, (int)window, 0); | |
| 530 | +} | |
| 531 | + | |
| 532 | + | |
| 533 | +void | |
| 534 | +setcolor(ulong index, ulong red, ulong green, ulong blue) | |
| 535 | +{ | |
| 536 | +} | |
| 537 | + | |
| 538 | + | |
| 539 | +uchar* | |
| 540 | +clipreadunicode(HANDLE h) | |
| 541 | +{ | |
| 542 | + Rune *p; | |
| 543 | + int n; | |
| 544 | + uchar *q; | |
| 545 | + | |
| 546 | + p = GlobalLock(h); | |
| 547 | + n = wstrutflen(p)+1; | |
| 548 | + q = malloc(n); | |
| 549 | + wstrtoutf(q, p, n); | |
| 550 | + GlobalUnlock(h); | |
| 551 | + | |
| 552 | + return q; | |
| 553 | +} | |
| 554 | + | |
| 555 | +uchar * | |
| 556 | +clipreadutf(HANDLE h) | |
| 557 | +{ | |
| 558 | + uchar *p; | |
| 559 | + | |
| 560 | + p = GlobalLock(h); | |
| 561 | + p = strdup(p); | |
| 562 | + GlobalUnlock(h); | |
| 563 | + | |
| 564 | + return p; | |
| 565 | +} | |
| 566 | + | |
| 567 | + | |
| 568 | +uchar* | |
| 569 | +clipread() | |
| 570 | +{ | |
| 571 | + HANDLE h; | |
| 572 | + uchar *p; | |
| 573 | + | |
| 574 | + if(!OpenClipboard(window)) { | |
| 575 | + oserror(); | |
| 576 | + return strdup(""); | |
| 577 | + } | |
| 578 | + | |
| 579 | + if(h = GetClipboardData(CF_UNICODETEXT)) | |
| 580 | + p = clipreadunicode(h); | |
| 581 | + else if(h = GetClipboardData(CF_TEXT)) | |
| 582 | + p = clipreadutf(h); | |
| 583 | + else { | |
| 584 | + oserror(); | |
| 585 | + p = strdup(""); | |
| 586 | + } | |
| 587 | + | |
| 588 | + CloseClipboard(); | |
| 589 | + return p; | |
| 590 | +} | |
| 591 | + | |
| 592 | +int | |
| 593 | +clipwrite(char *buf) | |
| 594 | +{ | |
| 595 | + HANDLE h; | |
| 596 | + char *p, *e; | |
| 597 | + Rune *rp; | |
| 598 | + int n = strlen(buf); | |
| 599 | + | |
| 600 | + if(!OpenClipboard(window)) { | |
| 601 | + oserror(); | |
| 602 | + return -1; | |
| 603 | + } | |
| 604 | + | |
| 605 | + if(!EmptyClipboard()) { | |
| 606 | + oserror(); | |
| 607 | + CloseClipboard(); | |
| 608 | + return -1; | |
| 609 | + } | |
| 610 | + | |
| 611 | + h = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE, (n+1)*sizeof(Rune)); | |
| 612 | + if(h == NULL) | |
| 613 | + panic("out of memory"); | |
| 614 | + rp = GlobalLock(h); | |
| 615 | + p = buf; | |
| 616 | + e = p+n; | |
| 617 | + while(p<e) | |
| 618 | + p += chartorune(rp++, p); | |
| 619 | + *rp = 0; | |
| 620 | + GlobalUnlock(h); | |
| 621 | + | |
| 622 | + SetClipboardData(CF_UNICODETEXT, h); | |
| 623 | + | |
| 624 | + h = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE, n+1); | |
| 625 | + if(h == NULL) | |
| 626 | + panic("out of memory"); | |
| 627 | + p = GlobalLock(h); | |
| 628 | + memcpy(p, buf, n); | |
| 629 | + p[n] = 0; | |
| 630 | + GlobalUnlock(h); | |
| 631 | + | |
| 632 | + SetClipboardData(CF_TEXT, h); | |
| 633 | + | |
| 634 | + CloseClipboard(); | |
| 635 | + return n; | |
| 636 | +} | |
| 637 | + | |
| 638 | +int | |
| 639 | +atlocalconsole(void) | |
| 640 | +{ | |
| 641 | + return 1; | |
| 642 | +} | |
| @@ -0,0 +1,35 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | + | |
| 4 | +int | |
| 5 | +wstrutflen(Rune *s) | |
| 6 | +{ | |
| 7 | + int n; | |
| 8 | + | |
| 9 | + for(n=0; *s; n+=runelen(*s),s++) | |
| 10 | + ; | |
| 11 | + return n; | |
| 12 | +} | |
| 13 | + | |
| 14 | +int | |
| 15 | +wstrtoutf(char *s, Rune *t, int n) | |
| 16 | +{ | |
| 17 | + int i; | |
| 18 | + char *s0; | |
| 19 | + | |
| 20 | + s0 = s; | |
| 21 | + if(n <= 0) | |
| 22 | + return wstrutflen(t)+1; | |
| 23 | + while(*t) { | |
| 24 | + if(n < UTFmax+1 && n < runelen(*t)+1) { | |
| 25 | + *s = 0; | |
| 26 | + return i+wstrutflen(t)+1; | |
| 27 | + } | |
| 28 | + i = runetochar(s, t); | |
| 29 | + s += i; | |
| 30 | + n -= i; | |
| 31 | + t++; | |
| 32 | + } | |
| 33 | + *s = 0; | |
| 34 | + return s-s0; | |
| 35 | +} | |
| @@ -0,0 +1,20 @@ | ||
| 1 | +LIB=libx11.a | |
| 2 | +CC=gcc | |
| 3 | +CFLAGS=-I../include -I. -I/usr/X11R6/include -I../kern -c -ggdb -D_THREAD_SAFE -pthread | |
| 4 | +O=o | |
| 5 | + | |
| 6 | +OFILES=\ | |
| 7 | + alloc.$O\ | |
| 8 | + cload.$O\ | |
| 9 | + draw.$O\ | |
| 10 | + load.$O\ | |
| 11 | + screen.$O\ | |
| 12 | + keysym2ucs-x11.$O | |
| 13 | + | |
| 14 | +$(LIB): $(OFILES) | |
| 15 | + ar r $(LIB) $(OFILES) | |
| 16 | + ranlib $(LIB) | |
| 17 | + | |
| 18 | +%.$O: %.c | |
| 19 | + $(CC) $(CFLAGS) $*.c | |
| 20 | + | |
| @@ -0,0 +1,209 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | +#include <draw.h> | |
| 4 | +#include <memdraw.h> | |
| 5 | +#include "xmem.h" | |
| 6 | + | |
| 7 | +/* perfect approximation to NTSC = .299r+.587g+.114b when 0 ≤ r,g,b < 256 */ | |
| 8 | +#define RGB2K(r,g,b) ((156763*(r)+307758*(g)+59769*(b))>>19) | |
| 9 | + | |
| 10 | +Memimage* | |
| 11 | +xallocmemimage(Rectangle r, ulong chan, int pmid) | |
| 12 | +{ | |
| 13 | + Memimage *m; | |
| 14 | + Xmem *xm; | |
| 15 | + XImage *xi; | |
| 16 | + int offset; | |
| 17 | + int d; | |
| 18 | + | |
| 19 | + m = _allocmemimage(r, chan); | |
| 20 | + if(chan != GREY1 && chan != xscreenchan) | |
| 21 | + return m; | |
| 22 | + | |
| 23 | + d = m->depth; | |
| 24 | + xm = mallocz(sizeof(Xmem), 1); | |
| 25 | + if(pmid != PMundef) | |
| 26 | + xm->pmid = pmid; | |
| 27 | + else | |
| 28 | + xm->pmid = XCreatePixmap(xdisplay, xscreenid, Dx(r), Dy(r), (d==32) ? 24 : d); | |
| 29 | + | |
| 30 | + if(m->depth == 24) | |
| 31 | + offset = r.min.x&(4-1); | |
| 32 | + else | |
| 33 | + offset = r.min.x&(31/m->depth); | |
| 34 | + r.min.x -= offset; | |
| 35 | + | |
| 36 | + assert(wordsperline(r, m->depth) <= m->width); | |
| 37 | + | |
| 38 | + xi = XCreateImage(xdisplay, xvis, m->depth==32?24:m->depth, ZPixmap, 0, | |
| 39 | + (char*)m->data->bdata, Dx(r), Dy(r), 32, m->width*sizeof(ulong)); | |
| 40 | + | |
| 41 | + if(xi == nil){ | |
| 42 | + _freememimage(m); | |
| 43 | + return nil; | |
| 44 | + } | |
| 45 | + | |
| 46 | + xm->xi = xi; | |
| 47 | + xm->pc = getcallerpc(&r); | |
| 48 | + xm->r = r; | |
| 49 | + | |
| 50 | + /* | |
| 51 | + * Set the parameters of the XImage so its memory looks exactly like a | |
| 52 | + * Memimage, so we can call _memimagedraw on the same data. All frame | |
| 53 | + * buffers we've seen, and Plan 9's graphics code, require big-endian | |
| 54 | + * bits within bytes, but little endian byte order within pixels. | |
| 55 | + */ | |
| 56 | + xi->bitmap_unit = m->depth < 8 || m->depth == 24 ? 8 : m->depth; | |
| 57 | + xi->byte_order = LSBFirst; | |
| 58 | + xi->bitmap_bit_order = MSBFirst; | |
| 59 | + xi->bitmap_pad = 32; | |
| 60 | + xm->r = Rect(0,0,0,0); | |
| 61 | + XInitImage(xi); | |
| 62 | + XFlush(xdisplay); | |
| 63 | + | |
| 64 | + m->X = xm; | |
| 65 | + return m; | |
| 66 | +} | |
| 67 | + | |
| 68 | +Memimage* | |
| 69 | +allocmemimage(Rectangle r, ulong chan) | |
| 70 | +{ | |
| 71 | + return xallocmemimage(r, chan, PMundef); | |
| 72 | +} | |
| 73 | + | |
| 74 | +void | |
| 75 | +freememimage(Memimage *m) | |
| 76 | +{ | |
| 77 | + Xmem *xm; | |
| 78 | + | |
| 79 | + if(m == nil) | |
| 80 | + return; | |
| 81 | + | |
| 82 | + if(m->data->ref == 1){ | |
| 83 | + if((xm = m->X) != nil){ | |
| 84 | + if(xm->xi){ | |
| 85 | + xm->xi->data = nil; | |
| 86 | + XFree(xm->xi); | |
| 87 | + } | |
| 88 | + XFreePixmap(xdisplay, xm->pmid); | |
| 89 | + free(xm); | |
| 90 | + m->X = nil; | |
| 91 | + } | |
| 92 | + } | |
| 93 | + _freememimage(m); | |
| 94 | +} | |
| 95 | + | |
| 96 | +void | |
| 97 | +memfillcolor(Memimage *m, ulong val) | |
| 98 | +{ | |
| 99 | + _memfillcolor(m, val); | |
| 100 | + if(m->X){ | |
| 101 | + if((val & 0xFF) == 0xFF) | |
| 102 | + xfillcolor(m, m->r, _rgbatoimg(m, val)); | |
| 103 | + else | |
| 104 | + putXdata(m, m->r); | |
| 105 | + } | |
| 106 | +} | |
| 107 | + | |
| 108 | +static void | |
| 109 | +addrect(Rectangle *rp, Rectangle r) | |
| 110 | +{ | |
| 111 | + if(rp->min.x >= rp->max.x) | |
| 112 | + *rp = r; | |
| 113 | + else | |
| 114 | + combinerect(rp, r); | |
| 115 | +} | |
| 116 | + | |
| 117 | +XImage* | |
| 118 | +getXdata(Memimage *m, Rectangle r) | |
| 119 | +{ | |
| 120 | + uchar *p; | |
| 121 | + int x, y; | |
| 122 | + Xmem *xm; | |
| 123 | + Point xdelta, delta; | |
| 124 | + Point tp; | |
| 125 | + | |
| 126 | + xm = m->X; | |
| 127 | + if(xm == nil) | |
| 128 | + return; | |
| 129 | + | |
| 130 | + assert(xm != nil && xm->xi != nil); | |
| 131 | + | |
| 132 | + if(xm->dirty == 0) | |
| 133 | + return xm->xi; | |
| 134 | + | |
| 135 | + r = xm->dirtyr; | |
| 136 | + if(Dx(r)==0 || Dy(r)==0) | |
| 137 | + return xm->xi; | |
| 138 | + | |
| 139 | + delta = subpt(r.min, m->r.min); | |
| 140 | + tp = xm->r.min; /* avoid unaligned access on digital unix */ | |
| 141 | + xdelta = subpt(r.min, tp); | |
| 142 | + | |
| 143 | + XGetSubImage(xdisplay, xm->pmid, delta.x, delta.y, Dx(r), Dy(r), | |
| 144 | + AllPlanes, ZPixmap, xm->xi, xdelta.x, xdelta.y); | |
| 145 | + | |
| 146 | + if(xtblbit && m->chan == CMAP8) | |
| 147 | + for(y=r.min.y; y<r.max.y; y++) | |
| 148 | + for(x=r.min.x, p=byteaddr(m, Pt(x,y)); x<r.max.x; x++, p++) | |
| 149 | + *p = x11toplan9[*p]; | |
| 150 | + | |
| 151 | + xm->dirty = 0; | |
| 152 | + xm->dirtyr = Rect(0,0,0,0); | |
| 153 | + return xm->xi; | |
| 154 | +} | |
| 155 | + | |
| 156 | +void | |
| 157 | +putXdata(Memimage *m, Rectangle r) | |
| 158 | +{ | |
| 159 | + Xmem *xm; | |
| 160 | + XImage *xi; | |
| 161 | + GC g; | |
| 162 | + int offset; | |
| 163 | + Point xdelta, delta; | |
| 164 | + Point tp; | |
| 165 | + int x, y; | |
| 166 | + uchar *p; | |
| 167 | + | |
| 168 | + xm = m->X; | |
| 169 | + if(xm == nil) | |
| 170 | + return; | |
| 171 | + | |
| 172 | + assert(xm != nil); | |
| 173 | + assert(xm->xi != nil); | |
| 174 | + | |
| 175 | + xi = xm->xi; | |
| 176 | + | |
| 177 | + g = (m->chan == GREY1) ? xgccopy0 : xgccopy; | |
| 178 | + if(m->depth == 24) | |
| 179 | + offset = r.min.x % 4; | |
| 180 | + else | |
| 181 | + offset = m->r.min.x & (31/m->depth); | |
| 182 | + | |
| 183 | + delta = subpt(r.min, m->r.min); | |
| 184 | + tp = xm->r.min; /* avoid unaligned access on digital unix */ | |
| 185 | + xdelta = subpt(r.min, tp); | |
| 186 | + | |
| 187 | + if(xtblbit && m->chan == CMAP8) | |
| 188 | + for(y=r.min.y; y<r.max.y; y++) | |
| 189 | + for(x=r.min.x, p=byteaddr(m, Pt(x,y)); x<r.max.x; x++, p++) | |
| 190 | + *p = plan9tox11[*p]; | |
| 191 | + | |
| 192 | + XPutImage(xdisplay, xm->pmid, g, xi, xdelta.x, xdelta.y, delta.x, delta.y, Dx(r), Dy(r)); | |
| 193 | + | |
| 194 | + if(xtblbit && m->chan == CMAP8) | |
| 195 | + for(y=r.min.y; y<r.max.y; y++) | |
| 196 | + for(x=r.min.x, p=byteaddr(m, Pt(x,y)); x<r.max.x; x++, p++) | |
| 197 | + *p = x11toplan9[*p]; | |
| 198 | +} | |
| 199 | + | |
| 200 | +void | |
| 201 | +dirtyXdata(Memimage *m, Rectangle r) | |
| 202 | +{ | |
| 203 | + Xmem *xm; | |
| 204 | + | |
| 205 | + if((xm = m->X) != nil){ | |
| 206 | + xm->dirty = 1; | |
| 207 | + addrect(&xm->dirtyr, r); | |
| 208 | + } | |
| 209 | +} | |
| @@ -0,0 +1,16 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | +#include <draw.h> | |
| 4 | +#include <memdraw.h> | |
| 5 | +#include "xmem.h" | |
| 6 | + | |
| 7 | +int | |
| 8 | +cloadmemimage(Memimage *i, Rectangle r, uchar *data, int ndata) | |
| 9 | +{ | |
| 10 | + int n; | |
| 11 | + | |
| 12 | + n = _cloadmemimage(i, r, data, ndata); | |
| 13 | + if(n > 0 && i->X) | |
| 14 | + putXdata(i, r); | |
| 15 | + return n; | |
| 16 | +} | |
| @@ -0,0 +1,189 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | +#include <draw.h> | |
| 4 | +#include <memdraw.h> | |
| 5 | +#include "xmem.h" | |
| 6 | + | |
| 7 | +void xfillcolor(Memimage*, Rectangle, ulong); | |
| 8 | +static int xdraw(Memdrawparam*); | |
| 9 | + | |
| 10 | +int xgcfillcolor = 0; | |
| 11 | +int xgcfillcolor0 = 0; | |
| 12 | +int xgczeropm = 0; | |
| 13 | +int xgczeropm0 = 0; | |
| 14 | +int xgcsimplecolor = 0; | |
| 15 | +int xgcsimplecolor0 = 0; | |
| 16 | +int xgcsimplepm = 0; | |
| 17 | +int xgcsimplepm0 = 0; | |
| 18 | +int xgcreplsrctile = 0; | |
| 19 | +int xgcreplsrctile0 = 0; | |
| 20 | + | |
| 21 | +void | |
| 22 | +memimageinit(void) | |
| 23 | +{ | |
| 24 | + static int didinit = 0; | |
| 25 | + | |
| 26 | + if(didinit) | |
| 27 | + return; | |
| 28 | + | |
| 29 | + didinit = 1; | |
| 30 | + _memimageinit(); | |
| 31 | + | |
| 32 | + xfillcolor(memblack, memblack->r, 0); | |
| 33 | + xfillcolor(memwhite, memwhite->r, 1); | |
| 34 | +} | |
| 35 | + | |
| 36 | +void | |
| 37 | +memimagedraw(Memimage *dst, Rectangle r, Memimage *src, Point sp, Memimage *mask, Point mp, int op) | |
| 38 | +{ | |
| 39 | + int didx; | |
| 40 | + Rectangle dr, mr, sr; | |
| 41 | + Memdrawparam *par; | |
| 42 | + | |
| 43 | + if((par = _memimagedrawsetup(dst, r, src, sp, mask, mp, op)) == nil) | |
| 44 | + return; | |
| 45 | + _memimagedraw(par); | |
| 46 | + if(!xdraw(par)) | |
| 47 | + putXdata(dst, par->r); | |
| 48 | +} | |
| 49 | + | |
| 50 | +void | |
| 51 | +xfillcolor(Memimage *m, Rectangle r, ulong v) | |
| 52 | +{ | |
| 53 | + GC gc; | |
| 54 | + Xmem *dxm; | |
| 55 | + | |
| 56 | + dxm = m->X; | |
| 57 | + assert(dxm != nil); | |
| 58 | + r = rectsubpt(r, m->r.min); | |
| 59 | + | |
| 60 | + if(m->chan == GREY1){ | |
| 61 | + gc = xgcfill0; | |
| 62 | + if(xgcfillcolor0 != v){ | |
| 63 | + XSetForeground(xdisplay, gc, v); | |
| 64 | + xgcfillcolor0 = v; | |
| 65 | + } | |
| 66 | + }else{ | |
| 67 | + if(m->chan == CMAP8 && xtblbit) | |
| 68 | + v = plan9tox11[v]; | |
| 69 | + | |
| 70 | + gc = xgcfill; | |
| 71 | + if(xgcfillcolor != v){ | |
| 72 | + XSetForeground(xdisplay, gc, v); | |
| 73 | + xgcfillcolor = v; | |
| 74 | + } | |
| 75 | + } | |
| 76 | + XFillRectangle(xdisplay, dxm->pmid, gc, r.min.x, r.min.y, Dx(r), Dy(r)); | |
| 77 | +} | |
| 78 | + | |
| 79 | +static int | |
| 80 | +xdraw(Memdrawparam *par) | |
| 81 | +{ | |
| 82 | + int dy, dx; | |
| 83 | + unsigned m; | |
| 84 | + Memimage *src, *dst, *mask; | |
| 85 | + Xmem *dxm, *sxm, *mxm; | |
| 86 | + GC gc; | |
| 87 | + Rectangle r, sr, mr; | |
| 88 | + ulong sdval; | |
| 89 | + | |
| 90 | + dx = Dx(par->r); | |
| 91 | + dy = Dy(par->r); | |
| 92 | + src = par->src; | |
| 93 | + dst = par->dst; | |
| 94 | + mask = par->mask; | |
| 95 | + r = par->r; | |
| 96 | + sr = par->sr; | |
| 97 | + mr = par->mr; | |
| 98 | + sdval = par->sdval; | |
| 99 | + | |
| 100 | +return 0; | |
| 101 | + if((dxm = dst->X) == nil) | |
| 102 | + return 0; | |
| 103 | + | |
| 104 | + /* | |
| 105 | + * If we have an opaque mask and source is one opaque pixel we can convert to the | |
| 106 | + * destination format and just XFillRectangle. | |
| 107 | + */ | |
| 108 | + m = Simplesrc|Simplemask|Fullmask; | |
| 109 | + if((par->state&m)==m){ | |
| 110 | + xfillcolor(dst, r, sdval); | |
| 111 | + dirtyXdata(dst, par->r); | |
| 112 | + return 1; | |
| 113 | + } | |
| 114 | + | |
| 115 | + /* | |
| 116 | + * If no source alpha, an opaque mask, we can just copy the | |
| 117 | + * source onto the destination. If the channels are the same and | |
| 118 | + * the source is not replicated, XCopyArea suffices. | |
| 119 | + */ | |
| 120 | + m = Simplemask|Fullmask; | |
| 121 | + if((par->state&(m|Replsrc))==m && src->chan == dst->chan && src->X){ | |
| 122 | + sxm = src->X; | |
| 123 | + r = rectsubpt(r, dst->r.min); | |
| 124 | + sr = rectsubpt(sr, src->r.min); | |
| 125 | + if(dst->chan == GREY1) | |
| 126 | + gc = xgccopy0; | |
| 127 | + else | |
| 128 | + gc = xgccopy; | |
| 129 | + XCopyArea(xdisplay, sxm->pmid, dxm->pmid, gc, | |
| 130 | + sr.min.x, sr.min.y, dx, dy, r.min.x, r.min.y); | |
| 131 | + dirtyXdata(dst, par->r); | |
| 132 | + return 1; | |
| 133 | + } | |
| 134 | + | |
| 135 | + /* | |
| 136 | + * If no source alpha, a 1-bit mask, and a simple source | |
| 137 | + * we can just copy through the mask onto the destination. | |
| 138 | + */ | |
| 139 | + if(dst->X && mask->X && !(mask->flags&Frepl) | |
| 140 | + && mask->chan == GREY1 && (par->state&Simplesrc)){ | |
| 141 | + Point p; | |
| 142 | + | |
| 143 | + mxm = mask->X; | |
| 144 | + r = rectsubpt(r, dst->r.min); | |
| 145 | + mr = rectsubpt(mr, mask->r.min); | |
| 146 | + p = subpt(r.min, mr.min); | |
| 147 | + if(dst->chan == GREY1){ | |
| 148 | + gc = xgcsimplesrc0; | |
| 149 | + if(xgcsimplecolor0 != sdval){ | |
| 150 | + XSetForeground(xdisplay, gc, sdval); | |
| 151 | + xgcsimplecolor0 = sdval; | |
| 152 | + } | |
| 153 | + if(xgcsimplepm0 != mxm->pmid){ | |
| 154 | + XSetStipple(xdisplay, gc, mxm->pmid); | |
| 155 | + xgcsimplepm0 = mxm->pmid; | |
| 156 | + } | |
| 157 | + }else{ | |
| 158 | + /* somehow this doesn't work on rob's mac | |
| 159 | + gc = xgcsimplesrc; | |
| 160 | + if(dst->chan == CMAP8 && xtblbit) | |
| 161 | + sdval = plan9tox11[sdval]; | |
| 162 | + | |
| 163 | + if(xgcsimplecolor != sdval){ | |
| 164 | + XSetForeground(xdisplay, gc, sdval); | |
| 165 | + xgcsimplecolor = sdval; | |
| 166 | + } | |
| 167 | + if(xgcsimplepm != mxm->pmid){ | |
| 168 | + XSetStipple(xdisplay, gc, mxm->pmid); | |
| 169 | + xgcsimplepm = mxm->pmid; | |
| 170 | + } | |
| 171 | + */ | |
| 172 | + return 0; | |
| 173 | + } | |
| 174 | + XSetTSOrigin(xdisplay, gc, p.x, p.y); | |
| 175 | + XFillRectangle(xdisplay, dxm->pmid, gc, r.min.x, r.min.y, dx, dy); | |
| 176 | + dirtyXdata(dst, par->r); | |
| 177 | + return 1; | |
| 178 | + } | |
| 179 | + return 0; | |
| 180 | +} | |
| 181 | + | |
| 182 | +ulong | |
| 183 | +pixelbits(Memimage *m, Point p) | |
| 184 | +{ | |
| 185 | + Xmem *xm; | |
| 186 | + if(m->X) | |
| 187 | + getXdata(m, Rect(p.x, p.y, p.x+1, p.y+1)); | |
| 188 | + return _pixelbits(m, p); | |
| 189 | +} | |
| @@ -0,0 +1,857 @@ | ||
| 1 | +/* $XFree86: xc/programs/xterm/keysym2ucs.c,v 1.5 2001/06/18 19:09:26 dickey Exp $ | |
| 2 | + * This module converts keysym values into the corresponding ISO 10646 | |
| 3 | + * (UCS, Unicode) values. | |
| 4 | + * | |
| 5 | + * The array keysymtab[] contains pairs of X11 keysym values for graphical | |
| 6 | + * characters and the corresponding Unicode value. The function | |
| 7 | + * keysym2ucs() maps a keysym onto a Unicode value using a binary search, | |
| 8 | + * therefore keysymtab[] must remain SORTED by keysym value. | |
| 9 | + * | |
| 10 | + * The keysym -> UTF-8 conversion will hopefully one day be provided | |
| 11 | + * by Xlib via XmbLookupString() and should ideally not have to be | |
| 12 | + * done in X applications. But we are not there yet. | |
| 13 | + * | |
| 14 | + * We allow to represent any UCS character in the range U-00000000 to | |
| 15 | + * U-00FFFFFF by a keysym value in the range 0x01000000 to 0x01ffffff. | |
| 16 | + * This admittedly does not cover the entire 31-bit space of UCS, but | |
| 17 | + * it does cover all of the characters up to U-10FFFF, which can be | |
| 18 | + * represented by UTF-16, and more, and it is very unlikely that higher | |
| 19 | + * UCS codes will ever be assigned by ISO. So to get Unicode character | |
| 20 | + * U+ABCD you can directly use keysym 0x0100abcd. | |
| 21 | + * | |
| 22 | + * NOTE: The comments in the table below contain the actual character | |
| 23 | + * encoded in UTF-8, so for viewing and editing best use an editor in | |
| 24 | + * UTF-8 mode. | |
| 25 | + * | |
| 26 | + * Author: Markus G. Kuhn <mkuhn@acm.org>, University of Cambridge, April 2001 | |
| 27 | + * | |
| 28 | + * Special thanks to Richard Verhoeven <river@win.tue.nl> for preparing | |
| 29 | + * an initial draft of the mapping table. | |
| 30 | + * | |
| 31 | + * This software is in the public domain. Share and enjoy! | |
| 32 | + * | |
| 33 | + * AUTOMATICALLY GENERATED FILE, DO NOT EDIT !!! (unicode/convmap.pl) | |
| 34 | + */ | |
| 35 | + | |
| 36 | +#ifndef KEYSYM2UCS_INCLUDED | |
| 37 | + | |
| 38 | +#include "keysym2ucs.h" | |
| 39 | +#define VISIBLE /* */ | |
| 40 | + | |
| 41 | +#else | |
| 42 | + | |
| 43 | +#define VISIBLE static | |
| 44 | + | |
| 45 | +#endif | |
| 46 | + | |
| 47 | +static struct codepair { | |
| 48 | + unsigned short keysym; | |
| 49 | + unsigned short ucs; | |
| 50 | +} keysymtab[] = { | |
| 51 | + { 0x01a1, 0x0104 }, /* Aogonek Ą LATIN CAPITAL LETTER A WITH OGONEK */ | |
| 52 | + { 0x01a2, 0x02d8 }, /* breve ˘ BREVE */ | |
| 53 | + { 0x01a3, 0x0141 }, /* Lstroke Ł LATIN CAPITAL LETTER L WITH STROKE */ | |
| 54 | + { 0x01a5, 0x013d }, /* Lcaron Ľ LATIN CAPITAL LETTER L WITH CARON */ | |
| 55 | + { 0x01a6, 0x015a }, /* Sacute Ś LATIN CAPITAL LETTER S WITH ACUTE */ | |
| 56 | + { 0x01a9, 0x0160 }, /* Scaron Š LATIN CAPITAL LETTER S WITH CARON */ | |
| 57 | + { 0x01aa, 0x015e }, /* Scedilla Ş LATIN CAPITAL LETTER S WITH CEDILLA */ | |
| 58 | + { 0x01ab, 0x0164 }, /* Tcaron Ť LATIN CAPITAL LETTER T WITH CARON */ | |
| 59 | + { 0x01ac, 0x0179 }, /* Zacute Ź LATIN CAPITAL LETTER Z WITH ACUTE */ | |
| 60 | + { 0x01ae, 0x017d }, /* Zcaron Ž LATIN CAPITAL LETTER Z WITH CARON */ | |
| 61 | + { 0x01af, 0x017b }, /* Zabovedot Ż LATIN CAPITAL LETTER Z WITH DOT ABOVE */ | |
| 62 | + { 0x01b1, 0x0105 }, /* aogonek ą LATIN SMALL LETTER A WITH OGONEK */ | |
| 63 | + { 0x01b2, 0x02db }, /* ogonek ˛ OGONEK */ | |
| 64 | + { 0x01b3, 0x0142 }, /* lstroke ł LATIN SMALL LETTER L WITH STROKE */ | |
| 65 | + { 0x01b5, 0x013e }, /* lcaron ľ LATIN SMALL LETTER L WITH CARON */ | |
| 66 | + { 0x01b6, 0x015b }, /* sacute ś LATIN SMALL LETTER S WITH ACUTE */ | |
| 67 | + { 0x01b7, 0x02c7 }, /* caron ˇ CARON */ | |
| 68 | + { 0x01b9, 0x0161 }, /* scaron š LATIN SMALL LETTER S WITH CARON */ | |
| 69 | + { 0x01ba, 0x015f }, /* scedilla ş LATIN SMALL LETTER S WITH CEDILLA */ | |
| 70 | + { 0x01bb, 0x0165 }, /* tcaron ť LATIN SMALL LETTER T WITH CARON */ | |
| 71 | + { 0x01bc, 0x017a }, /* zacute ź LATIN SMALL LETTER Z WITH ACUTE */ | |
| 72 | + { 0x01bd, 0x02dd }, /* doubleacute ˝ DOUBLE ACUTE ACCENT */ | |
| 73 | + { 0x01be, 0x017e }, /* zcaron ž LATIN SMALL LETTER Z WITH CARON */ | |
| 74 | + { 0x01bf, 0x017c }, /* zabovedot ż LATIN SMALL LETTER Z WITH DOT ABOVE */ | |
| 75 | + { 0x01c0, 0x0154 }, /* Racute Ŕ LATIN CAPITAL LETTER R WITH ACUTE */ | |
| 76 | + { 0x01c3, 0x0102 }, /* Abreve Ă LATIN CAPITAL LETTER A WITH BREVE */ | |
| 77 | + { 0x01c5, 0x0139 }, /* Lacute Ĺ LATIN CAPITAL LETTER L WITH ACUTE */ | |
| 78 | + { 0x01c6, 0x0106 }, /* Cacute Ć LATIN CAPITAL LETTER C WITH ACUTE */ | |
| 79 | + { 0x01c8, 0x010c }, /* Ccaron Č LATIN CAPITAL LETTER C WITH CARON */ | |
| 80 | + { 0x01ca, 0x0118 }, /* Eogonek Ę LATIN CAPITAL LETTER E WITH OGONEK */ | |
| 81 | + { 0x01cc, 0x011a }, /* Ecaron Ě LATIN CAPITAL LETTER E WITH CARON */ | |
| 82 | + { 0x01cf, 0x010e }, /* Dcaron Ď LATIN CAPITAL LETTER D WITH CARON */ | |
| 83 | + { 0x01d0, 0x0110 }, /* Dstroke Đ LATIN CAPITAL LETTER D WITH STROKE */ | |
| 84 | + { 0x01d1, 0x0143 }, /* Nacute Ń LATIN CAPITAL LETTER N WITH ACUTE */ | |
| 85 | + { 0x01d2, 0x0147 }, /* Ncaron Ň LATIN CAPITAL LETTER N WITH CARON */ | |
| 86 | + { 0x01d5, 0x0150 }, /* Odoubleacute Ő LATIN CAPITAL LETTER O WITH DOUBLE ACUTE */ | |
| 87 | + { 0x01d8, 0x0158 }, /* Rcaron Ř LATIN CAPITAL LETTER R WITH CARON */ | |
| 88 | + { 0x01d9, 0x016e }, /* Uring Ů LATIN CAPITAL LETTER U WITH RING ABOVE */ | |
| 89 | + { 0x01db, 0x0170 }, /* Udoubleacute Ű LATIN CAPITAL LETTER U WITH DOUBLE ACUTE */ | |
| 90 | + { 0x01de, 0x0162 }, /* Tcedilla Ţ LATIN CAPITAL LETTER T WITH CEDILLA */ | |
| 91 | + { 0x01e0, 0x0155 }, /* racute ŕ LATIN SMALL LETTER R WITH ACUTE */ | |
| 92 | + { 0x01e3, 0x0103 }, /* abreve ă LATIN SMALL LETTER A WITH BREVE */ | |
| 93 | + { 0x01e5, 0x013a }, /* lacute ĺ LATIN SMALL LETTER L WITH ACUTE */ | |
| 94 | + { 0x01e6, 0x0107 }, /* cacute ć LATIN SMALL LETTER C WITH ACUTE */ | |
| 95 | + { 0x01e8, 0x010d }, /* ccaron č LATIN SMALL LETTER C WITH CARON */ | |
| 96 | + { 0x01ea, 0x0119 }, /* eogonek ę LATIN SMALL LETTER E WITH OGONEK */ | |
| 97 | + { 0x01ec, 0x011b }, /* ecaron ě LATIN SMALL LETTER E WITH CARON */ | |
| 98 | + { 0x01ef, 0x010f }, /* dcaron ď LATIN SMALL LETTER D WITH CARON */ | |
| 99 | + { 0x01f0, 0x0111 }, /* dstroke đ LATIN SMALL LETTER D WITH STROKE */ | |
| 100 | + { 0x01f1, 0x0144 }, /* nacute ń LATIN SMALL LETTER N WITH ACUTE */ | |
| 101 | + { 0x01f2, 0x0148 }, /* ncaron ň LATIN SMALL LETTER N WITH CARON */ | |
| 102 | + { 0x01f5, 0x0151 }, /* odoubleacute ő LATIN SMALL LETTER O WITH DOUBLE ACUTE */ | |
| 103 | + { 0x01f8, 0x0159 }, /* rcaron ř LATIN SMALL LETTER R WITH CARON */ | |
| 104 | + { 0x01f9, 0x016f }, /* uring ů LATIN SMALL LETTER U WITH RING ABOVE */ | |
| 105 | + { 0x01fb, 0x0171 }, /* udoubleacute ű LATIN SMALL LETTER U WITH DOUBLE ACUTE */ | |
| 106 | + { 0x01fe, 0x0163 }, /* tcedilla ţ LATIN SMALL LETTER T WITH CEDILLA */ | |
| 107 | + { 0x01ff, 0x02d9 }, /* abovedot ˙ DOT ABOVE */ | |
| 108 | + { 0x02a1, 0x0126 }, /* Hstroke Ħ LATIN CAPITAL LETTER H WITH STROKE */ | |
| 109 | + { 0x02a6, 0x0124 }, /* Hcircumflex Ĥ LATIN CAPITAL LETTER H WITH CIRCUMFLEX */ | |
| 110 | + { 0x02a9, 0x0130 }, /* Iabovedot İ LATIN CAPITAL LETTER I WITH DOT ABOVE */ | |
| 111 | + { 0x02ab, 0x011e }, /* Gbreve Ğ LATIN CAPITAL LETTER G WITH BREVE */ | |
| 112 | + { 0x02ac, 0x0134 }, /* Jcircumflex Ĵ LATIN CAPITAL LETTER J WITH CIRCUMFLEX */ | |
| 113 | + { 0x02b1, 0x0127 }, /* hstroke ħ LATIN SMALL LETTER H WITH STROKE */ | |
| 114 | + { 0x02b6, 0x0125 }, /* hcircumflex ĥ LATIN SMALL LETTER H WITH CIRCUMFLEX */ | |
| 115 | + { 0x02b9, 0x0131 }, /* idotless ı LATIN SMALL LETTER DOTLESS I */ | |
| 116 | + { 0x02bb, 0x011f }, /* gbreve ğ LATIN SMALL LETTER G WITH BREVE */ | |
| 117 | + { 0x02bc, 0x0135 }, /* jcircumflex ĵ LATIN SMALL LETTER J WITH CIRCUMFLEX */ | |
| 118 | + { 0x02c5, 0x010a }, /* Cabovedot Ċ LATIN CAPITAL LETTER C WITH DOT ABOVE */ | |
| 119 | + { 0x02c6, 0x0108 }, /* Ccircumflex Ĉ LATIN CAPITAL LETTER C WITH CIRCUMFLEX */ | |
| 120 | + { 0x02d5, 0x0120 }, /* Gabovedot Ġ LATIN CAPITAL LETTER G WITH DOT ABOVE */ | |
| 121 | + { 0x02d8, 0x011c }, /* Gcircumflex Ĝ LATIN CAPITAL LETTER G WITH CIRCUMFLEX */ | |
| 122 | + { 0x02dd, 0x016c }, /* Ubreve Ŭ LATIN CAPITAL LETTER U WITH BREVE */ | |
| 123 | + { 0x02de, 0x015c }, /* Scircumflex Ŝ LATIN CAPITAL LETTER S WITH CIRCUMFLEX */ | |
| 124 | + { 0x02e5, 0x010b }, /* cabovedot ċ LATIN SMALL LETTER C WITH DOT ABOVE */ | |
| 125 | + { 0x02e6, 0x0109 }, /* ccircumflex ĉ LATIN SMALL LETTER C WITH CIRCUMFLEX */ | |
| 126 | + { 0x02f5, 0x0121 }, /* gabovedot ġ LATIN SMALL LETTER G WITH DOT ABOVE */ | |
| 127 | + { 0x02f8, 0x011d }, /* gcircumflex ĝ LATIN SMALL LETTER G WITH CIRCUMFLEX */ | |
| 128 | + { 0x02fd, 0x016d }, /* ubreve ŭ LATIN SMALL LETTER U WITH BREVE */ | |
| 129 | + { 0x02fe, 0x015d }, /* scircumflex ŝ LATIN SMALL LETTER S WITH CIRCUMFLEX */ | |
| 130 | + { 0x03a2, 0x0138 }, /* kra ĸ LATIN SMALL LETTER KRA */ | |
| 131 | + { 0x03a3, 0x0156 }, /* Rcedilla Ŗ LATIN CAPITAL LETTER R WITH CEDILLA */ | |
| 132 | + { 0x03a5, 0x0128 }, /* Itilde Ĩ LATIN CAPITAL LETTER I WITH TILDE */ | |
| 133 | + { 0x03a6, 0x013b }, /* Lcedilla Ļ LATIN CAPITAL LETTER L WITH CEDILLA */ | |
| 134 | + { 0x03aa, 0x0112 }, /* Emacron Ē LATIN CAPITAL LETTER E WITH MACRON */ | |
| 135 | + { 0x03ab, 0x0122 }, /* Gcedilla Ģ LATIN CAPITAL LETTER G WITH CEDILLA */ | |
| 136 | + { 0x03ac, 0x0166 }, /* Tslash Ŧ LATIN CAPITAL LETTER T WITH STROKE */ | |
| 137 | + { 0x03b3, 0x0157 }, /* rcedilla ŗ LATIN SMALL LETTER R WITH CEDILLA */ | |
| 138 | + { 0x03b5, 0x0129 }, /* itilde ĩ LATIN SMALL LETTER I WITH TILDE */ | |
| 139 | + { 0x03b6, 0x013c }, /* lcedilla ļ LATIN SMALL LETTER L WITH CEDILLA */ | |
| 140 | + { 0x03ba, 0x0113 }, /* emacron ē LATIN SMALL LETTER E WITH MACRON */ | |
| 141 | + { 0x03bb, 0x0123 }, /* gcedilla ģ LATIN SMALL LETTER G WITH CEDILLA */ | |
| 142 | + { 0x03bc, 0x0167 }, /* tslash ŧ LATIN SMALL LETTER T WITH STROKE */ | |
| 143 | + { 0x03bd, 0x014a }, /* ENG Ŋ LATIN CAPITAL LETTER ENG */ | |
| 144 | + { 0x03bf, 0x014b }, /* eng ŋ LATIN SMALL LETTER ENG */ | |
| 145 | + { 0x03c0, 0x0100 }, /* Amacron Ā LATIN CAPITAL LETTER A WITH MACRON */ | |
| 146 | + { 0x03c7, 0x012e }, /* Iogonek Į LATIN CAPITAL LETTER I WITH OGONEK */ | |
| 147 | + { 0x03cc, 0x0116 }, /* Eabovedot Ė LATIN CAPITAL LETTER E WITH DOT ABOVE */ | |
| 148 | + { 0x03cf, 0x012a }, /* Imacron Ī LATIN CAPITAL LETTER I WITH MACRON */ | |
| 149 | + { 0x03d1, 0x0145 }, /* Ncedilla Ņ LATIN CAPITAL LETTER N WITH CEDILLA */ | |
| 150 | + { 0x03d2, 0x014c }, /* Omacron Ō LATIN CAPITAL LETTER O WITH MACRON */ | |
| 151 | + { 0x03d3, 0x0136 }, /* Kcedilla Ķ LATIN CAPITAL LETTER K WITH CEDILLA */ | |
| 152 | + { 0x03d9, 0x0172 }, /* Uogonek Ų LATIN CAPITAL LETTER U WITH OGONEK */ | |
| 153 | + { 0x03dd, 0x0168 }, /* Utilde Ũ LATIN CAPITAL LETTER U WITH TILDE */ | |
| 154 | + { 0x03de, 0x016a }, /* Umacron Ū LATIN CAPITAL LETTER U WITH MACRON */ | |
| 155 | + { 0x03e0, 0x0101 }, /* amacron ā LATIN SMALL LETTER A WITH MACRON */ | |
| 156 | + { 0x03e7, 0x012f }, /* iogonek į LATIN SMALL LETTER I WITH OGONEK */ | |
| 157 | + { 0x03ec, 0x0117 }, /* eabovedot ė LATIN SMALL LETTER E WITH DOT ABOVE */ | |
| 158 | + { 0x03ef, 0x012b }, /* imacron ī LATIN SMALL LETTER I WITH MACRON */ | |
| 159 | + { 0x03f1, 0x0146 }, /* ncedilla ņ LATIN SMALL LETTER N WITH CEDILLA */ | |
| 160 | + { 0x03f2, 0x014d }, /* omacron ō LATIN SMALL LETTER O WITH MACRON */ | |
| 161 | + { 0x03f3, 0x0137 }, /* kcedilla ķ LATIN SMALL LETTER K WITH CEDILLA */ | |
| 162 | + { 0x03f9, 0x0173 }, /* uogonek ų LATIN SMALL LETTER U WITH OGONEK */ | |
| 163 | + { 0x03fd, 0x0169 }, /* utilde ũ LATIN SMALL LETTER U WITH TILDE */ | |
| 164 | + { 0x03fe, 0x016b }, /* umacron ū LATIN SMALL LETTER U WITH MACRON */ | |
| 165 | + { 0x047e, 0x203e }, /* overline ‾ OVERLINE */ | |
| 166 | + { 0x04a1, 0x3002 }, /* kana_fullstop 。 IDEOGRAPHIC FULL STOP */ | |
| 167 | + { 0x04a2, 0x300c }, /* kana_openingbracket 「 LEFT CORNER BRACKET */ | |
| 168 | + { 0x04a3, 0x300d }, /* kana_closingbracket 」 RIGHT CORNER BRACKET */ | |
| 169 | + { 0x04a4, 0x3001 }, /* kana_comma 、 IDEOGRAPHIC COMMA */ | |
| 170 | + { 0x04a5, 0x30fb }, /* kana_conjunctive ・ KATAKANA MIDDLE DOT */ | |
| 171 | + { 0x04a6, 0x30f2 }, /* kana_WO ヲ KATAKANA LETTER WO */ | |
| 172 | + { 0x04a7, 0x30a1 }, /* kana_a ァ KATAKANA LETTER SMALL A */ | |
| 173 | + { 0x04a8, 0x30a3 }, /* kana_i ィ KATAKANA LETTER SMALL I */ | |
| 174 | + { 0x04a9, 0x30a5 }, /* kana_u ゥ KATAKANA LETTER SMALL U */ | |
| 175 | + { 0x04aa, 0x30a7 }, /* kana_e ェ KATAKANA LETTER SMALL E */ | |
| 176 | + { 0x04ab, 0x30a9 }, /* kana_o ォ KATAKANA LETTER SMALL O */ | |
| 177 | + { 0x04ac, 0x30e3 }, /* kana_ya ャ KATAKANA LETTER SMALL YA */ | |
| 178 | + { 0x04ad, 0x30e5 }, /* kana_yu ュ KATAKANA LETTER SMALL YU */ | |
| 179 | + { 0x04ae, 0x30e7 }, /* kana_yo ョ KATAKANA LETTER SMALL YO */ | |
| 180 | + { 0x04af, 0x30c3 }, /* kana_tsu ッ KATAKANA LETTER SMALL TU */ | |
| 181 | + { 0x04b0, 0x30fc }, /* prolongedsound ー KATAKANA-HIRAGANA PROLONGED SOUND MARK */ | |
| 182 | + { 0x04b1, 0x30a2 }, /* kana_A ア KATAKANA LETTER A */ | |
| 183 | + { 0x04b2, 0x30a4 }, /* kana_I イ KATAKANA LETTER I */ | |
| 184 | + { 0x04b3, 0x30a6 }, /* kana_U ウ KATAKANA LETTER U */ | |
| 185 | + { 0x04b4, 0x30a8 }, /* kana_E エ KATAKANA LETTER E */ | |
| 186 | + { 0x04b5, 0x30aa }, /* kana_O オ KATAKANA LETTER O */ | |
| 187 | + { 0x04b6, 0x30ab }, /* kana_KA カ KATAKANA LETTER KA */ | |
| 188 | + { 0x04b7, 0x30ad }, /* kana_KI キ KATAKANA LETTER KI */ | |
| 189 | + { 0x04b8, 0x30af }, /* kana_KU ク KATAKANA LETTER KU */ | |
| 190 | + { 0x04b9, 0x30b1 }, /* kana_KE ケ KATAKANA LETTER KE */ | |
| 191 | + { 0x04ba, 0x30b3 }, /* kana_KO コ KATAKANA LETTER KO */ | |
| 192 | + { 0x04bb, 0x30b5 }, /* kana_SA サ KATAKANA LETTER SA */ | |
| 193 | + { 0x04bc, 0x30b7 }, /* kana_SHI シ KATAKANA LETTER SI */ | |
| 194 | + { 0x04bd, 0x30b9 }, /* kana_SU ス KATAKANA LETTER SU */ | |
| 195 | + { 0x04be, 0x30bb }, /* kana_SE セ KATAKANA LETTER SE */ | |
| 196 | + { 0x04bf, 0x30bd }, /* kana_SO ソ KATAKANA LETTER SO */ | |
| 197 | + { 0x04c0, 0x30bf }, /* kana_TA タ KATAKANA LETTER TA */ | |
| 198 | + { 0x04c1, 0x30c1 }, /* kana_CHI チ KATAKANA LETTER TI */ | |
| 199 | + { 0x04c2, 0x30c4 }, /* kana_TSU ツ KATAKANA LETTER TU */ | |
| 200 | + { 0x04c3, 0x30c6 }, /* kana_TE テ KATAKANA LETTER TE */ | |
| 201 | + { 0x04c4, 0x30c8 }, /* kana_TO ト KATAKANA LETTER TO */ | |
| 202 | + { 0x04c5, 0x30ca }, /* kana_NA ナ KATAKANA LETTER NA */ | |
| 203 | + { 0x04c6, 0x30cb }, /* kana_NI ニ KATAKANA LETTER NI */ | |
| 204 | + { 0x04c7, 0x30cc }, /* kana_NU ヌ KATAKANA LETTER NU */ | |
| 205 | + { 0x04c8, 0x30cd }, /* kana_NE ネ KATAKANA LETTER NE */ | |
| 206 | + { 0x04c9, 0x30ce }, /* kana_NO ノ KATAKANA LETTER NO */ | |
| 207 | + { 0x04ca, 0x30cf }, /* kana_HA ハ KATAKANA LETTER HA */ | |
| 208 | + { 0x04cb, 0x30d2 }, /* kana_HI ヒ KATAKANA LETTER HI */ | |
| 209 | + { 0x04cc, 0x30d5 }, /* kana_FU フ KATAKANA LETTER HU */ | |
| 210 | + { 0x04cd, 0x30d8 }, /* kana_HE ヘ KATAKANA LETTER HE */ | |
| 211 | + { 0x04ce, 0x30db }, /* kana_HO ホ KATAKANA LETTER HO */ | |
| 212 | + { 0x04cf, 0x30de }, /* kana_MA マ KATAKANA LETTER MA */ | |
| 213 | + { 0x04d0, 0x30df }, /* kana_MI ミ KATAKANA LETTER MI */ | |
| 214 | + { 0x04d1, 0x30e0 }, /* kana_MU ム KATAKANA LETTER MU */ | |
| 215 | + { 0x04d2, 0x30e1 }, /* kana_ME メ KATAKANA LETTER ME */ | |
| 216 | + { 0x04d3, 0x30e2 }, /* kana_MO モ KATAKANA LETTER MO */ | |
| 217 | + { 0x04d4, 0x30e4 }, /* kana_YA ヤ KATAKANA LETTER YA */ | |
| 218 | + { 0x04d5, 0x30e6 }, /* kana_YU ユ KATAKANA LETTER YU */ | |
| 219 | + { 0x04d6, 0x30e8 }, /* kana_YO ヨ KATAKANA LETTER YO */ | |
| 220 | + { 0x04d7, 0x30e9 }, /* kana_RA ラ KATAKANA LETTER RA */ | |
| 221 | + { 0x04d8, 0x30ea }, /* kana_RI リ KATAKANA LETTER RI */ | |
| 222 | + { 0x04d9, 0x30eb }, /* kana_RU ル KATAKANA LETTER RU */ | |
| 223 | + { 0x04da, 0x30ec }, /* kana_RE レ KATAKANA LETTER RE */ | |
| 224 | + { 0x04db, 0x30ed }, /* kana_RO ロ KATAKANA LETTER RO */ | |
| 225 | + { 0x04dc, 0x30ef }, /* kana_WA ワ KATAKANA LETTER WA */ | |
| 226 | + { 0x04dd, 0x30f3 }, /* kana_N ン KATAKANA LETTER N */ | |
| 227 | + { 0x04de, 0x309b }, /* voicedsound ゛ KATAKANA-HIRAGANA VOICED SOUND MARK */ | |
| 228 | + { 0x04df, 0x309c }, /* semivoicedsound ゜ KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK */ | |
| 229 | + { 0x05ac, 0x060c }, /* Arabic_comma ، ARABIC COMMA */ | |
| 230 | + { 0x05bb, 0x061b }, /* Arabic_semicolon ؛ ARABIC SEMICOLON */ | |
| 231 | + { 0x05bf, 0x061f }, /* Arabic_question_mark ؟ ARABIC QUESTION MARK */ | |
| 232 | + { 0x05c1, 0x0621 }, /* Arabic_hamza ء ARABIC LETTER HAMZA */ | |
| 233 | + { 0x05c2, 0x0622 }, /* Arabic_maddaonalef آ ARABIC LETTER ALEF WITH MADDA ABOVE */ | |
| 234 | + { 0x05c3, 0x0623 }, /* Arabic_hamzaonalef أ ARABIC LETTER ALEF WITH HAMZA ABOVE */ | |
| 235 | + { 0x05c4, 0x0624 }, /* Arabic_hamzaonwaw ؤ ARABIC LETTER WAW WITH HAMZA ABOVE */ | |
| 236 | + { 0x05c5, 0x0625 }, /* Arabic_hamzaunderalef إ ARABIC LETTER ALEF WITH HAMZA BELOW */ | |
| 237 | + { 0x05c6, 0x0626 }, /* Arabic_hamzaonyeh ئ ARABIC LETTER YEH WITH HAMZA ABOVE */ | |
| 238 | + { 0x05c7, 0x0627 }, /* Arabic_alef ا ARABIC LETTER ALEF */ | |
| 239 | + { 0x05c8, 0x0628 }, /* Arabic_beh ب ARABIC LETTER BEH */ | |
| 240 | + { 0x05c9, 0x0629 }, /* Arabic_tehmarbuta ة ARABIC LETTER TEH MARBUTA */ | |
| 241 | + { 0x05ca, 0x062a }, /* Arabic_teh ت ARABIC LETTER TEH */ | |
| 242 | + { 0x05cb, 0x062b }, /* Arabic_theh ث ARABIC LETTER THEH */ | |
| 243 | + { 0x05cc, 0x062c }, /* Arabic_jeem ج ARABIC LETTER JEEM */ | |
| 244 | + { 0x05cd, 0x062d }, /* Arabic_hah ح ARABIC LETTER HAH */ | |
| 245 | + { 0x05ce, 0x062e }, /* Arabic_khah خ ARABIC LETTER KHAH */ | |
| 246 | + { 0x05cf, 0x062f }, /* Arabic_dal د ARABIC LETTER DAL */ | |
| 247 | + { 0x05d0, 0x0630 }, /* Arabic_thal ذ ARABIC LETTER THAL */ | |
| 248 | + { 0x05d1, 0x0631 }, /* Arabic_ra ر ARABIC LETTER REH */ | |
| 249 | + { 0x05d2, 0x0632 }, /* Arabic_zain ز ARABIC LETTER ZAIN */ | |
| 250 | + { 0x05d3, 0x0633 }, /* Arabic_seen س ARABIC LETTER SEEN */ | |
| 251 | + { 0x05d4, 0x0634 }, /* Arabic_sheen ش ARABIC LETTER SHEEN */ | |
| 252 | + { 0x05d5, 0x0635 }, /* Arabic_sad ص ARABIC LETTER SAD */ | |
| 253 | + { 0x05d6, 0x0636 }, /* Arabic_dad ض ARABIC LETTER DAD */ | |
| 254 | + { 0x05d7, 0x0637 }, /* Arabic_tah ط ARABIC LETTER TAH */ | |
| 255 | + { 0x05d8, 0x0638 }, /* Arabic_zah ظ ARABIC LETTER ZAH */ | |
| 256 | + { 0x05d9, 0x0639 }, /* Arabic_ain ع ARABIC LETTER AIN */ | |
| 257 | + { 0x05da, 0x063a }, /* Arabic_ghain غ ARABIC LETTER GHAIN */ | |
| 258 | + { 0x05e0, 0x0640 }, /* Arabic_tatweel ـ ARABIC TATWEEL */ | |
| 259 | + { 0x05e1, 0x0641 }, /* Arabic_feh ف ARABIC LETTER FEH */ | |
| 260 | + { 0x05e2, 0x0642 }, /* Arabic_qaf ق ARABIC LETTER QAF */ | |
| 261 | + { 0x05e3, 0x0643 }, /* Arabic_kaf ك ARABIC LETTER KAF */ | |
| 262 | + { 0x05e4, 0x0644 }, /* Arabic_lam ل ARABIC LETTER LAM */ | |
| 263 | + { 0x05e5, 0x0645 }, /* Arabic_meem م ARABIC LETTER MEEM */ | |
| 264 | + { 0x05e6, 0x0646 }, /* Arabic_noon ن ARABIC LETTER NOON */ | |
| 265 | + { 0x05e7, 0x0647 }, /* Arabic_ha ه ARABIC LETTER HEH */ | |
| 266 | + { 0x05e8, 0x0648 }, /* Arabic_waw و ARABIC LETTER WAW */ | |
| 267 | + { 0x05e9, 0x0649 }, /* Arabic_alefmaksura ى ARABIC LETTER ALEF MAKSURA */ | |
| 268 | + { 0x05ea, 0x064a }, /* Arabic_yeh ي ARABIC LETTER YEH */ | |
| 269 | + { 0x05eb, 0x064b }, /* Arabic_fathatan ً ARABIC FATHATAN */ | |
| 270 | + { 0x05ec, 0x064c }, /* Arabic_dammatan ٌ ARABIC DAMMATAN */ | |
| 271 | + { 0x05ed, 0x064d }, /* Arabic_kasratan ٍ ARABIC KASRATAN */ | |
| 272 | + { 0x05ee, 0x064e }, /* Arabic_fatha َ ARABIC FATHA */ | |
| 273 | + { 0x05ef, 0x064f }, /* Arabic_damma ُ ARABIC DAMMA */ | |
| 274 | + { 0x05f0, 0x0650 }, /* Arabic_kasra ِ ARABIC KASRA */ | |
| 275 | + { 0x05f1, 0x0651 }, /* Arabic_shadda ّ ARABIC SHADDA */ | |
| 276 | + { 0x05f2, 0x0652 }, /* Arabic_sukun ْ ARABIC SUKUN */ | |
| 277 | + { 0x06a1, 0x0452 }, /* Serbian_dje ђ CYRILLIC SMALL LETTER DJE */ | |
| 278 | + { 0x06a2, 0x0453 }, /* Macedonia_gje ѓ CYRILLIC SMALL LETTER GJE */ | |
| 279 | + { 0x06a3, 0x0451 }, /* Cyrillic_io ё CYRILLIC SMALL LETTER IO */ | |
| 280 | + { 0x06a4, 0x0454 }, /* Ukrainian_ie є CYRILLIC SMALL LETTER UKRAINIAN IE */ | |
| 281 | + { 0x06a5, 0x0455 }, /* Macedonia_dse ѕ CYRILLIC SMALL LETTER DZE */ | |
| 282 | + { 0x06a6, 0x0456 }, /* Ukrainian_i і CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I */ | |
| 283 | + { 0x06a7, 0x0457 }, /* Ukrainian_yi ї CYRILLIC SMALL LETTER YI */ | |
| 284 | + { 0x06a8, 0x0458 }, /* Cyrillic_je ј CYRILLIC SMALL LETTER JE */ | |
| 285 | + { 0x06a9, 0x0459 }, /* Cyrillic_lje љ CYRILLIC SMALL LETTER LJE */ | |
| 286 | + { 0x06aa, 0x045a }, /* Cyrillic_nje њ CYRILLIC SMALL LETTER NJE */ | |
| 287 | + { 0x06ab, 0x045b }, /* Serbian_tshe ћ CYRILLIC SMALL LETTER TSHE */ | |
| 288 | + { 0x06ac, 0x045c }, /* Macedonia_kje ќ CYRILLIC SMALL LETTER KJE */ | |
| 289 | + { 0x06ae, 0x045e }, /* Byelorussian_shortu ў CYRILLIC SMALL LETTER SHORT U */ | |
| 290 | + { 0x06af, 0x045f }, /* Cyrillic_dzhe џ CYRILLIC SMALL LETTER DZHE */ | |
| 291 | + { 0x06b0, 0x2116 }, /* numerosign № NUMERO SIGN */ | |
| 292 | + { 0x06b1, 0x0402 }, /* Serbian_DJE Ђ CYRILLIC CAPITAL LETTER DJE */ | |
| 293 | + { 0x06b2, 0x0403 }, /* Macedonia_GJE Ѓ CYRILLIC CAPITAL LETTER GJE */ | |
| 294 | + { 0x06b3, 0x0401 }, /* Cyrillic_IO Ё CYRILLIC CAPITAL LETTER IO */ | |
| 295 | + { 0x06b4, 0x0404 }, /* Ukrainian_IE Є CYRILLIC CAPITAL LETTER UKRAINIAN IE */ | |
| 296 | + { 0x06b5, 0x0405 }, /* Macedonia_DSE Ѕ CYRILLIC CAPITAL LETTER DZE */ | |
| 297 | + { 0x06b6, 0x0406 }, /* Ukrainian_I І CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I */ | |
| 298 | + { 0x06b7, 0x0407 }, /* Ukrainian_YI Ї CYRILLIC CAPITAL LETTER YI */ | |
| 299 | + { 0x06b8, 0x0408 }, /* Cyrillic_JE Ј CYRILLIC CAPITAL LETTER JE */ | |
| 300 | + { 0x06b9, 0x0409 }, /* Cyrillic_LJE Љ CYRILLIC CAPITAL LETTER LJE */ | |
| 301 | + { 0x06ba, 0x040a }, /* Cyrillic_NJE Њ CYRILLIC CAPITAL LETTER NJE */ | |
| 302 | + { 0x06bb, 0x040b }, /* Serbian_TSHE Ћ CYRILLIC CAPITAL LETTER TSHE */ | |
| 303 | + { 0x06bc, 0x040c }, /* Macedonia_KJE Ќ CYRILLIC CAPITAL LETTER KJE */ | |
| 304 | + { 0x06be, 0x040e }, /* Byelorussian_SHORTU Ў CYRILLIC CAPITAL LETTER SHORT U */ | |
| 305 | + { 0x06bf, 0x040f }, /* Cyrillic_DZHE Џ CYRILLIC CAPITAL LETTER DZHE */ | |
| 306 | + { 0x06c0, 0x044e }, /* Cyrillic_yu ю CYRILLIC SMALL LETTER YU */ | |
| 307 | + { 0x06c1, 0x0430 }, /* Cyrillic_a а CYRILLIC SMALL LETTER A */ | |
| 308 | + { 0x06c2, 0x0431 }, /* Cyrillic_be б CYRILLIC SMALL LETTER BE */ | |
| 309 | + { 0x06c3, 0x0446 }, /* Cyrillic_tse ц CYRILLIC SMALL LETTER TSE */ | |
| 310 | + { 0x06c4, 0x0434 }, /* Cyrillic_de д CYRILLIC SMALL LETTER DE */ | |
| 311 | + { 0x06c5, 0x0435 }, /* Cyrillic_ie е CYRILLIC SMALL LETTER IE */ | |
| 312 | + { 0x06c6, 0x0444 }, /* Cyrillic_ef ф CYRILLIC SMALL LETTER EF */ | |
| 313 | + { 0x06c7, 0x0433 }, /* Cyrillic_ghe г CYRILLIC SMALL LETTER GHE */ | |
| 314 | + { 0x06c8, 0x0445 }, /* Cyrillic_ha х CYRILLIC SMALL LETTER HA */ | |
| 315 | + { 0x06c9, 0x0438 }, /* Cyrillic_i и CYRILLIC SMALL LETTER I */ | |
| 316 | + { 0x06ca, 0x0439 }, /* Cyrillic_shorti й CYRILLIC SMALL LETTER SHORT I */ | |
| 317 | + { 0x06cb, 0x043a }, /* Cyrillic_ka к CYRILLIC SMALL LETTER KA */ | |
| 318 | + { 0x06cc, 0x043b }, /* Cyrillic_el л CYRILLIC SMALL LETTER EL */ | |
| 319 | + { 0x06cd, 0x043c }, /* Cyrillic_em м CYRILLIC SMALL LETTER EM */ | |
| 320 | + { 0x06ce, 0x043d }, /* Cyrillic_en н CYRILLIC SMALL LETTER EN */ | |
| 321 | + { 0x06cf, 0x043e }, /* Cyrillic_o о CYRILLIC SMALL LETTER O */ | |
| 322 | + { 0x06d0, 0x043f }, /* Cyrillic_pe п CYRILLIC SMALL LETTER PE */ | |
| 323 | + { 0x06d1, 0x044f }, /* Cyrillic_ya я CYRILLIC SMALL LETTER YA */ | |
| 324 | + { 0x06d2, 0x0440 }, /* Cyrillic_er р CYRILLIC SMALL LETTER ER */ | |
| 325 | + { 0x06d3, 0x0441 }, /* Cyrillic_es с CYRILLIC SMALL LETTER ES */ | |
| 326 | + { 0x06d4, 0x0442 }, /* Cyrillic_te т CYRILLIC SMALL LETTER TE */ | |
| 327 | + { 0x06d5, 0x0443 }, /* Cyrillic_u у CYRILLIC SMALL LETTER U */ | |
| 328 | + { 0x06d6, 0x0436 }, /* Cyrillic_zhe ж CYRILLIC SMALL LETTER ZHE */ | |
| 329 | + { 0x06d7, 0x0432 }, /* Cyrillic_ve в CYRILLIC SMALL LETTER VE */ | |
| 330 | + { 0x06d8, 0x044c }, /* Cyrillic_softsign ь CYRILLIC SMALL LETTER SOFT SIGN */ | |
| 331 | + { 0x06d9, 0x044b }, /* Cyrillic_yeru ы CYRILLIC SMALL LETTER YERU */ | |
| 332 | + { 0x06da, 0x0437 }, /* Cyrillic_ze з CYRILLIC SMALL LETTER ZE */ | |
| 333 | + { 0x06db, 0x0448 }, /* Cyrillic_sha ш CYRILLIC SMALL LETTER SHA */ | |
| 334 | + { 0x06dc, 0x044d }, /* Cyrillic_e э CYRILLIC SMALL LETTER E */ | |
| 335 | + { 0x06dd, 0x0449 }, /* Cyrillic_shcha щ CYRILLIC SMALL LETTER SHCHA */ | |
| 336 | + { 0x06de, 0x0447 }, /* Cyrillic_che ч CYRILLIC SMALL LETTER CHE */ | |
| 337 | + { 0x06df, 0x044a }, /* Cyrillic_hardsign ъ CYRILLIC SMALL LETTER HARD SIGN */ | |
| 338 | + { 0x06e0, 0x042e }, /* Cyrillic_YU Ю CYRILLIC CAPITAL LETTER YU */ | |
| 339 | + { 0x06e1, 0x0410 }, /* Cyrillic_A А CYRILLIC CAPITAL LETTER A */ | |
| 340 | + { 0x06e2, 0x0411 }, /* Cyrillic_BE Б CYRILLIC CAPITAL LETTER BE */ | |
| 341 | + { 0x06e3, 0x0426 }, /* Cyrillic_TSE Ц CYRILLIC CAPITAL LETTER TSE */ | |
| 342 | + { 0x06e4, 0x0414 }, /* Cyrillic_DE Д CYRILLIC CAPITAL LETTER DE */ | |
| 343 | + { 0x06e5, 0x0415 }, /* Cyrillic_IE Е CYRILLIC CAPITAL LETTER IE */ | |
| 344 | + { 0x06e6, 0x0424 }, /* Cyrillic_EF Ф CYRILLIC CAPITAL LETTER EF */ | |
| 345 | + { 0x06e7, 0x0413 }, /* Cyrillic_GHE Г CYRILLIC CAPITAL LETTER GHE */ | |
| 346 | + { 0x06e8, 0x0425 }, /* Cyrillic_HA Х CYRILLIC CAPITAL LETTER HA */ | |
| 347 | + { 0x06e9, 0x0418 }, /* Cyrillic_I И CYRILLIC CAPITAL LETTER I */ | |
| 348 | + { 0x06ea, 0x0419 }, /* Cyrillic_SHORTI Й CYRILLIC CAPITAL LETTER SHORT I */ | |
| 349 | + { 0x06eb, 0x041a }, /* Cyrillic_KA К CYRILLIC CAPITAL LETTER KA */ | |
| 350 | + { 0x06ec, 0x041b }, /* Cyrillic_EL Л CYRILLIC CAPITAL LETTER EL */ | |
| 351 | + { 0x06ed, 0x041c }, /* Cyrillic_EM М CYRILLIC CAPITAL LETTER EM */ | |
| 352 | + { 0x06ee, 0x041d }, /* Cyrillic_EN Н CYRILLIC CAPITAL LETTER EN */ | |
| 353 | + { 0x06ef, 0x041e }, /* Cyrillic_O О CYRILLIC CAPITAL LETTER O */ | |
| 354 | + { 0x06f0, 0x041f }, /* Cyrillic_PE П CYRILLIC CAPITAL LETTER PE */ | |
| 355 | + { 0x06f1, 0x042f }, /* Cyrillic_YA Я CYRILLIC CAPITAL LETTER YA */ | |
| 356 | + { 0x06f2, 0x0420 }, /* Cyrillic_ER Р CYRILLIC CAPITAL LETTER ER */ | |
| 357 | + { 0x06f3, 0x0421 }, /* Cyrillic_ES С CYRILLIC CAPITAL LETTER ES */ | |
| 358 | + { 0x06f4, 0x0422 }, /* Cyrillic_TE Т CYRILLIC CAPITAL LETTER TE */ | |
| 359 | + { 0x06f5, 0x0423 }, /* Cyrillic_U У CYRILLIC CAPITAL LETTER U */ | |
| 360 | + { 0x06f6, 0x0416 }, /* Cyrillic_ZHE Ж CYRILLIC CAPITAL LETTER ZHE */ | |
| 361 | + { 0x06f7, 0x0412 }, /* Cyrillic_VE В CYRILLIC CAPITAL LETTER VE */ | |
| 362 | + { 0x06f8, 0x042c }, /* Cyrillic_SOFTSIGN Ь CYRILLIC CAPITAL LETTER SOFT SIGN */ | |
| 363 | + { 0x06f9, 0x042b }, /* Cyrillic_YERU Ы CYRILLIC CAPITAL LETTER YERU */ | |
| 364 | + { 0x06fa, 0x0417 }, /* Cyrillic_ZE З CYRILLIC CAPITAL LETTER ZE */ | |
| 365 | + { 0x06fb, 0x0428 }, /* Cyrillic_SHA Ш CYRILLIC CAPITAL LETTER SHA */ | |
| 366 | + { 0x06fc, 0x042d }, /* Cyrillic_E Э CYRILLIC CAPITAL LETTER E */ | |
| 367 | + { 0x06fd, 0x0429 }, /* Cyrillic_SHCHA Щ CYRILLIC CAPITAL LETTER SHCHA */ | |
| 368 | + { 0x06fe, 0x0427 }, /* Cyrillic_CHE Ч CYRILLIC CAPITAL LETTER CHE */ | |
| 369 | + { 0x06ff, 0x042a }, /* Cyrillic_HARDSIGN Ъ CYRILLIC CAPITAL LETTER HARD SIGN */ | |
| 370 | + { 0x07a1, 0x0386 }, /* Greek_ALPHAaccent Ά GREEK CAPITAL LETTER ALPHA WITH TONOS */ | |
| 371 | + { 0x07a2, 0x0388 }, /* Greek_EPSILONaccent Έ GREEK CAPITAL LETTER EPSILON WITH TONOS */ | |
| 372 | + { 0x07a3, 0x0389 }, /* Greek_ETAaccent Ή GREEK CAPITAL LETTER ETA WITH TONOS */ | |
| 373 | + { 0x07a4, 0x038a }, /* Greek_IOTAaccent Ί GREEK CAPITAL LETTER IOTA WITH TONOS */ | |
| 374 | + { 0x07a5, 0x03aa }, /* Greek_IOTAdiaeresis Ϊ GREEK CAPITAL LETTER IOTA WITH DIALYTIKA */ | |
| 375 | + { 0x07a7, 0x038c }, /* Greek_OMICRONaccent Ό GREEK CAPITAL LETTER OMICRON WITH TONOS */ | |
| 376 | + { 0x07a8, 0x038e }, /* Greek_UPSILONaccent Ύ GREEK CAPITAL LETTER UPSILON WITH TONOS */ | |
| 377 | + { 0x07a9, 0x03ab }, /* Greek_UPSILONdieresis Ϋ GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA */ | |
| 378 | + { 0x07ab, 0x038f }, /* Greek_OMEGAaccent Ώ GREEK CAPITAL LETTER OMEGA WITH TONOS */ | |
| 379 | + { 0x07ae, 0x0385 }, /* Greek_accentdieresis ΅ GREEK DIALYTIKA TONOS */ | |
| 380 | + { 0x07af, 0x2015 }, /* Greek_horizbar ― HORIZONTAL BAR */ | |
| 381 | + { 0x07b1, 0x03ac }, /* Greek_alphaaccent ά GREEK SMALL LETTER ALPHA WITH TONOS */ | |
| 382 | + { 0x07b2, 0x03ad }, /* Greek_epsilonaccent έ GREEK SMALL LETTER EPSILON WITH TONOS */ | |
| 383 | + { 0x07b3, 0x03ae }, /* Greek_etaaccent ή GREEK SMALL LETTER ETA WITH TONOS */ | |
| 384 | + { 0x07b4, 0x03af }, /* Greek_iotaaccent ί GREEK SMALL LETTER IOTA WITH TONOS */ | |
| 385 | + { 0x07b5, 0x03ca }, /* Greek_iotadieresis ϊ GREEK SMALL LETTER IOTA WITH DIALYTIKA */ | |
| 386 | + { 0x07b6, 0x0390 }, /* Greek_iotaaccentdieresis ΐ GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS */ | |
| 387 | + { 0x07b7, 0x03cc }, /* Greek_omicronaccent ό GREEK SMALL LETTER OMICRON WITH TONOS */ | |
| 388 | + { 0x07b8, 0x03cd }, /* Greek_upsilonaccent ύ GREEK SMALL LETTER UPSILON WITH TONOS */ | |
| 389 | + { 0x07b9, 0x03cb }, /* Greek_upsilondieresis ϋ GREEK SMALL LETTER UPSILON WITH DIALYTIKA */ | |
| 390 | + { 0x07ba, 0x03b0 }, /* Greek_upsilonaccentdieresis ΰ GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS */ | |
| 391 | + { 0x07bb, 0x03ce }, /* Greek_omegaaccent ώ GREEK SMALL LETTER OMEGA WITH TONOS */ | |
| 392 | + { 0x07c1, 0x0391 }, /* Greek_ALPHA Α GREEK CAPITAL LETTER ALPHA */ | |
| 393 | + { 0x07c2, 0x0392 }, /* Greek_BETA Β GREEK CAPITAL LETTER BETA */ | |
| 394 | + { 0x07c3, 0x0393 }, /* Greek_GAMMA Γ GREEK CAPITAL LETTER GAMMA */ | |
| 395 | + { 0x07c4, 0x0394 }, /* Greek_DELTA Δ GREEK CAPITAL LETTER DELTA */ | |
| 396 | + { 0x07c5, 0x0395 }, /* Greek_EPSILON Ε GREEK CAPITAL LETTER EPSILON */ | |
| 397 | + { 0x07c6, 0x0396 }, /* Greek_ZETA Ζ GREEK CAPITAL LETTER ZETA */ | |
| 398 | + { 0x07c7, 0x0397 }, /* Greek_ETA Η GREEK CAPITAL LETTER ETA */ | |
| 399 | + { 0x07c8, 0x0398 }, /* Greek_THETA Θ GREEK CAPITAL LETTER THETA */ | |
| 400 | + { 0x07c9, 0x0399 }, /* Greek_IOTA Ι GREEK CAPITAL LETTER IOTA */ | |
| 401 | + { 0x07ca, 0x039a }, /* Greek_KAPPA Κ GREEK CAPITAL LETTER KAPPA */ | |
| 402 | + { 0x07cb, 0x039b }, /* Greek_LAMBDA Λ GREEK CAPITAL LETTER LAMDA */ | |
| 403 | + { 0x07cc, 0x039c }, /* Greek_MU Μ GREEK CAPITAL LETTER MU */ | |
| 404 | + { 0x07cd, 0x039d }, /* Greek_NU Ν GREEK CAPITAL LETTER NU */ | |
| 405 | + { 0x07ce, 0x039e }, /* Greek_XI Ξ GREEK CAPITAL LETTER XI */ | |
| 406 | + { 0x07cf, 0x039f }, /* Greek_OMICRON Ο GREEK CAPITAL LETTER OMICRON */ | |
| 407 | + { 0x07d0, 0x03a0 }, /* Greek_PI Π GREEK CAPITAL LETTER PI */ | |
| 408 | + { 0x07d1, 0x03a1 }, /* Greek_RHO Ρ GREEK CAPITAL LETTER RHO */ | |
| 409 | + { 0x07d2, 0x03a3 }, /* Greek_SIGMA Σ GREEK CAPITAL LETTER SIGMA */ | |
| 410 | + { 0x07d4, 0x03a4 }, /* Greek_TAU Τ GREEK CAPITAL LETTER TAU */ | |
| 411 | + { 0x07d5, 0x03a5 }, /* Greek_UPSILON Υ GREEK CAPITAL LETTER UPSILON */ | |
| 412 | + { 0x07d6, 0x03a6 }, /* Greek_PHI Φ GREEK CAPITAL LETTER PHI */ | |
| 413 | + { 0x07d7, 0x03a7 }, /* Greek_CHI Χ GREEK CAPITAL LETTER CHI */ | |
| 414 | + { 0x07d8, 0x03a8 }, /* Greek_PSI Ψ GREEK CAPITAL LETTER PSI */ | |
| 415 | + { 0x07d9, 0x03a9 }, /* Greek_OMEGA Ω GREEK CAPITAL LETTER OMEGA */ | |
| 416 | + { 0x07e1, 0x03b1 }, /* Greek_alpha α GREEK SMALL LETTER ALPHA */ | |
| 417 | + { 0x07e2, 0x03b2 }, /* Greek_beta β GREEK SMALL LETTER BETA */ | |
| 418 | + { 0x07e3, 0x03b3 }, /* Greek_gamma γ GREEK SMALL LETTER GAMMA */ | |
| 419 | + { 0x07e4, 0x03b4 }, /* Greek_delta δ GREEK SMALL LETTER DELTA */ | |
| 420 | + { 0x07e5, 0x03b5 }, /* Greek_epsilon ε GREEK SMALL LETTER EPSILON */ | |
| 421 | + { 0x07e6, 0x03b6 }, /* Greek_zeta ζ GREEK SMALL LETTER ZETA */ | |
| 422 | + { 0x07e7, 0x03b7 }, /* Greek_eta η GREEK SMALL LETTER ETA */ | |
| 423 | + { 0x07e8, 0x03b8 }, /* Greek_theta θ GREEK SMALL LETTER THETA */ | |
| 424 | + { 0x07e9, 0x03b9 }, /* Greek_iota ι GREEK SMALL LETTER IOTA */ | |
| 425 | + { 0x07ea, 0x03ba }, /* Greek_kappa κ GREEK SMALL LETTER KAPPA */ | |
| 426 | + { 0x07eb, 0x03bb }, /* Greek_lambda λ GREEK SMALL LETTER LAMDA */ | |
| 427 | + { 0x07ec, 0x03bc }, /* Greek_mu μ GREEK SMALL LETTER MU */ | |
| 428 | + { 0x07ed, 0x03bd }, /* Greek_nu ν GREEK SMALL LETTER NU */ | |
| 429 | + { 0x07ee, 0x03be }, /* Greek_xi ξ GREEK SMALL LETTER XI */ | |
| 430 | + { 0x07ef, 0x03bf }, /* Greek_omicron ο GREEK SMALL LETTER OMICRON */ | |
| 431 | + { 0x07f0, 0x03c0 }, /* Greek_pi π GREEK SMALL LETTER PI */ | |
| 432 | + { 0x07f1, 0x03c1 }, /* Greek_rho ρ GREEK SMALL LETTER RHO */ | |
| 433 | + { 0x07f2, 0x03c3 }, /* Greek_sigma σ GREEK SMALL LETTER SIGMA */ | |
| 434 | + { 0x07f3, 0x03c2 }, /* Greek_finalsmallsigma ς GREEK SMALL LETTER FINAL SIGMA */ | |
| 435 | + { 0x07f4, 0x03c4 }, /* Greek_tau τ GREEK SMALL LETTER TAU */ | |
| 436 | + { 0x07f5, 0x03c5 }, /* Greek_upsilon υ GREEK SMALL LETTER UPSILON */ | |
| 437 | + { 0x07f6, 0x03c6 }, /* Greek_phi φ GREEK SMALL LETTER PHI */ | |
| 438 | + { 0x07f7, 0x03c7 }, /* Greek_chi χ GREEK SMALL LETTER CHI */ | |
| 439 | + { 0x07f8, 0x03c8 }, /* Greek_psi ψ GREEK SMALL LETTER PSI */ | |
| 440 | + { 0x07f9, 0x03c9 }, /* Greek_omega ω GREEK SMALL LETTER OMEGA */ | |
| 441 | + { 0x08a1, 0x23b7 }, /* leftradical ⎷ ??? */ | |
| 442 | + { 0x08a2, 0x250c }, /* topleftradical ┌ BOX DRAWINGS LIGHT DOWN AND RIGHT */ | |
| 443 | + { 0x08a3, 0x2500 }, /* horizconnector ─ BOX DRAWINGS LIGHT HORIZONTAL */ | |
| 444 | + { 0x08a4, 0x2320 }, /* topintegral ⌠ TOP HALF INTEGRAL */ | |
| 445 | + { 0x08a5, 0x2321 }, /* botintegral ⌡ BOTTOM HALF INTEGRAL */ | |
| 446 | + { 0x08a6, 0x2502 }, /* vertconnector │ BOX DRAWINGS LIGHT VERTICAL */ | |
| 447 | + { 0x08a7, 0x23a1 }, /* topleftsqbracket ⎡ ??? */ | |
| 448 | + { 0x08a8, 0x23a3 }, /* botleftsqbracket ⎣ ??? */ | |
| 449 | + { 0x08a9, 0x23a4 }, /* toprightsqbracket ⎤ ??? */ | |
| 450 | + { 0x08aa, 0x23a6 }, /* botrightsqbracket ⎦ ??? */ | |
| 451 | + { 0x08ab, 0x239b }, /* topleftparens ⎛ ??? */ | |
| 452 | + { 0x08ac, 0x239d }, /* botleftparens ⎝ ??? */ | |
| 453 | + { 0x08ad, 0x239e }, /* toprightparens ⎞ ??? */ | |
| 454 | + { 0x08ae, 0x23a0 }, /* botrightparens ⎠ ??? */ | |
| 455 | + { 0x08af, 0x23a8 }, /* leftmiddlecurlybrace ⎨ ??? */ | |
| 456 | + { 0x08b0, 0x23ac }, /* rightmiddlecurlybrace ⎬ ??? */ | |
| 457 | +/* 0x08b1 topleftsummation ? ??? */ | |
| 458 | +/* 0x08b2 botleftsummation ? ??? */ | |
| 459 | +/* 0x08b3 topvertsummationconnector ? ??? */ | |
| 460 | +/* 0x08b4 botvertsummationconnector ? ??? */ | |
| 461 | +/* 0x08b5 toprightsummation ? ??? */ | |
| 462 | +/* 0x08b6 botrightsummation ? ??? */ | |
| 463 | +/* 0x08b7 rightmiddlesummation ? ??? */ | |
| 464 | + { 0x08bc, 0x2264 }, /* lessthanequal ≤ LESS-THAN OR EQUAL TO */ | |
| 465 | + { 0x08bd, 0x2260 }, /* notequal ≠ NOT EQUAL TO */ | |
| 466 | + { 0x08be, 0x2265 }, /* greaterthanequal ≥ GREATER-THAN OR EQUAL TO */ | |
| 467 | + { 0x08bf, 0x222b }, /* integral ∫ INTEGRAL */ | |
| 468 | + { 0x08c0, 0x2234 }, /* therefore ∴ THEREFORE */ | |
| 469 | + { 0x08c1, 0x221d }, /* variation ∝ PROPORTIONAL TO */ | |
| 470 | + { 0x08c2, 0x221e }, /* infinity ∞ INFINITY */ | |
| 471 | + { 0x08c5, 0x2207 }, /* nabla ∇ NABLA */ | |
| 472 | + { 0x08c8, 0x223c }, /* approximate ∼ TILDE OPERATOR */ | |
| 473 | + { 0x08c9, 0x2243 }, /* similarequal ≃ ASYMPTOTICALLY EQUAL TO */ | |
| 474 | + { 0x08cd, 0x21d4 }, /* ifonlyif ⇔ LEFT RIGHT DOUBLE ARROW */ | |
| 475 | + { 0x08ce, 0x21d2 }, /* implies ⇒ RIGHTWARDS DOUBLE ARROW */ | |
| 476 | + { 0x08cf, 0x2261 }, /* identical ≡ IDENTICAL TO */ | |
| 477 | + { 0x08d6, 0x221a }, /* radical √ SQUARE ROOT */ | |
| 478 | + { 0x08da, 0x2282 }, /* includedin ⊂ SUBSET OF */ | |
| 479 | + { 0x08db, 0x2283 }, /* includes ⊃ SUPERSET OF */ | |
| 480 | + { 0x08dc, 0x2229 }, /* intersection ∩ INTERSECTION */ | |
| 481 | + { 0x08dd, 0x222a }, /* union ∪ UNION */ | |
| 482 | + { 0x08de, 0x2227 }, /* logicaland ∧ LOGICAL AND */ | |
| 483 | + { 0x08df, 0x2228 }, /* logicalor ∨ LOGICAL OR */ | |
| 484 | + { 0x08ef, 0x2202 }, /* partialderivative ∂ PARTIAL DIFFERENTIAL */ | |
| 485 | + { 0x08f6, 0x0192 }, /* function ƒ LATIN SMALL LETTER F WITH HOOK */ | |
| 486 | + { 0x08fb, 0x2190 }, /* leftarrow ← LEFTWARDS ARROW */ | |
| 487 | + { 0x08fc, 0x2191 }, /* uparrow ↑ UPWARDS ARROW */ | |
| 488 | + { 0x08fd, 0x2192 }, /* rightarrow → RIGHTWARDS ARROW */ | |
| 489 | + { 0x08fe, 0x2193 }, /* downarrow ↓ DOWNWARDS ARROW */ | |
| 490 | +/* 0x09df blank ? ??? */ | |
| 491 | + { 0x09e0, 0x25c6 }, /* soliddiamond ◆ BLACK DIAMOND */ | |
| 492 | + { 0x09e1, 0x2592 }, /* checkerboard ▒ MEDIUM SHADE */ | |
| 493 | + { 0x09e2, 0x2409 }, /* ht ␉ SYMBOL FOR HORIZONTAL TABULATION */ | |
| 494 | + { 0x09e3, 0x240c }, /* ff ␌ SYMBOL FOR FORM FEED */ | |
| 495 | + { 0x09e4, 0x240d }, /* cr ␍ SYMBOL FOR CARRIAGE RETURN */ | |
| 496 | + { 0x09e5, 0x240a }, /* lf ␊ SYMBOL FOR LINE FEED */ | |
| 497 | + { 0x09e8, 0x2424 }, /* nl  SYMBOL FOR NEWLINE */ | |
| 498 | + { 0x09e9, 0x240b }, /* vt ␋ SYMBOL FOR VERTICAL TABULATION */ | |
| 499 | + { 0x09ea, 0x2518 }, /* lowrightcorner ┘ BOX DRAWINGS LIGHT UP AND LEFT */ | |
| 500 | + { 0x09eb, 0x2510 }, /* uprightcorner ┐ BOX DRAWINGS LIGHT DOWN AND LEFT */ | |
| 501 | + { 0x09ec, 0x250c }, /* upleftcorner ┌ BOX DRAWINGS LIGHT DOWN AND RIGHT */ | |
| 502 | + { 0x09ed, 0x2514 }, /* lowleftcorner └ BOX DRAWINGS LIGHT UP AND RIGHT */ | |
| 503 | + { 0x09ee, 0x253c }, /* crossinglines ┼ BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL */ | |
| 504 | + { 0x09ef, 0x23ba }, /* horizlinescan1 ⎺ HORIZONTAL SCAN LINE-1 (Unicode 3.2 draft) */ | |
| 505 | + { 0x09f0, 0x23bb }, /* horizlinescan3 ⎻ HORIZONTAL SCAN LINE-3 (Unicode 3.2 draft) */ | |
| 506 | + { 0x09f1, 0x2500 }, /* horizlinescan5 ─ BOX DRAWINGS LIGHT HORIZONTAL */ | |
| 507 | + { 0x09f2, 0x23bc }, /* horizlinescan7 ⎼ HORIZONTAL SCAN LINE-7 (Unicode 3.2 draft) */ | |
| 508 | + { 0x09f3, 0x23bd }, /* horizlinescan9 ⎽ HORIZONTAL SCAN LINE-9 (Unicode 3.2 draft) */ | |
| 509 | + { 0x09f4, 0x251c }, /* leftt ├ BOX DRAWINGS LIGHT VERTICAL AND RIGHT */ | |
| 510 | + { 0x09f5, 0x2524 }, /* rightt ┤ BOX DRAWINGS LIGHT VERTICAL AND LEFT */ | |
| 511 | + { 0x09f6, 0x2534 }, /* bott ┴ BOX DRAWINGS LIGHT UP AND HORIZONTAL */ | |
| 512 | + { 0x09f7, 0x252c }, /* topt ┬ BOX DRAWINGS LIGHT DOWN AND HORIZONTAL */ | |
| 513 | + { 0x09f8, 0x2502 }, /* vertbar │ BOX DRAWINGS LIGHT VERTICAL */ | |
| 514 | + { 0x0aa1, 0x2003 }, /* emspace EM SPACE */ | |
| 515 | + { 0x0aa2, 0x2002 }, /* enspace EN SPACE */ | |
| 516 | + { 0x0aa3, 0x2004 }, /* em3space THREE-PER-EM SPACE */ | |
| 517 | + { 0x0aa4, 0x2005 }, /* em4space FOUR-PER-EM SPACE */ | |
| 518 | + { 0x0aa5, 0x2007 }, /* digitspace FIGURE SPACE */ | |
| 519 | + { 0x0aa6, 0x2008 }, /* punctspace PUNCTUATION SPACE */ | |
| 520 | + { 0x0aa7, 0x2009 }, /* thinspace THIN SPACE */ | |
| 521 | + { 0x0aa8, 0x200a }, /* hairspace HAIR SPACE */ | |
| 522 | + { 0x0aa9, 0x2014 }, /* emdash — EM DASH */ | |
| 523 | + { 0x0aaa, 0x2013 }, /* endash – EN DASH */ | |
| 524 | +/* 0x0aac signifblank ? ??? */ | |
| 525 | + { 0x0aae, 0x2026 }, /* ellipsis … HORIZONTAL ELLIPSIS */ | |
| 526 | + { 0x0aaf, 0x2025 }, /* doubbaselinedot ‥ TWO DOT LEADER */ | |
| 527 | + { 0x0ab0, 0x2153 }, /* onethird ⅓ VULGAR FRACTION ONE THIRD */ | |
| 528 | + { 0x0ab1, 0x2154 }, /* twothirds ⅔ VULGAR FRACTION TWO THIRDS */ | |
| 529 | + { 0x0ab2, 0x2155 }, /* onefifth ⅕ VULGAR FRACTION ONE FIFTH */ | |
| 530 | + { 0x0ab3, 0x2156 }, /* twofifths ⅖ VULGAR FRACTION TWO FIFTHS */ | |
| 531 | + { 0x0ab4, 0x2157 }, /* threefifths ⅗ VULGAR FRACTION THREE FIFTHS */ | |
| 532 | + { 0x0ab5, 0x2158 }, /* fourfifths ⅘ VULGAR FRACTION FOUR FIFTHS */ | |
| 533 | + { 0x0ab6, 0x2159 }, /* onesixth ⅙ VULGAR FRACTION ONE SIXTH */ | |
| 534 | + { 0x0ab7, 0x215a }, /* fivesixths ⅚ VULGAR FRACTION FIVE SIXTHS */ | |
| 535 | + { 0x0ab8, 0x2105 }, /* careof ℅ CARE OF */ | |
| 536 | + { 0x0abb, 0x2012 }, /* figdash ‒ FIGURE DASH */ | |
| 537 | + { 0x0abc, 0x2329 }, /* leftanglebracket 〈 LEFT-POINTING ANGLE BRACKET */ | |
| 538 | +/* 0x0abd decimalpoint ? ??? */ | |
| 539 | + { 0x0abe, 0x232a }, /* rightanglebracket 〉 RIGHT-POINTING ANGLE BRACKET */ | |
| 540 | +/* 0x0abf marker ? ??? */ | |
| 541 | + { 0x0ac3, 0x215b }, /* oneeighth ⅛ VULGAR FRACTION ONE EIGHTH */ | |
| 542 | + { 0x0ac4, 0x215c }, /* threeeighths ⅜ VULGAR FRACTION THREE EIGHTHS */ | |
| 543 | + { 0x0ac5, 0x215d }, /* fiveeighths ⅝ VULGAR FRACTION FIVE EIGHTHS */ | |
| 544 | + { 0x0ac6, 0x215e }, /* seveneighths ⅞ VULGAR FRACTION SEVEN EIGHTHS */ | |
| 545 | + { 0x0ac9, 0x2122 }, /* trademark ™ TRADE MARK SIGN */ | |
| 546 | + { 0x0aca, 0x2613 }, /* signaturemark ☓ SALTIRE */ | |
| 547 | +/* 0x0acb trademarkincircle ? ??? */ | |
| 548 | + { 0x0acc, 0x25c1 }, /* leftopentriangle ◁ WHITE LEFT-POINTING TRIANGLE */ | |
| 549 | + { 0x0acd, 0x25b7 }, /* rightopentriangle ▷ WHITE RIGHT-POINTING TRIANGLE */ | |
| 550 | + { 0x0ace, 0x25cb }, /* emopencircle ○ WHITE CIRCLE */ | |
| 551 | + { 0x0acf, 0x25af }, /* emopenrectangle ▯ WHITE VERTICAL RECTANGLE */ | |
| 552 | + { 0x0ad0, 0x2018 }, /* leftsinglequotemark ‘ LEFT SINGLE QUOTATION MARK */ | |
| 553 | + { 0x0ad1, 0x2019 }, /* rightsinglequotemark ’ RIGHT SINGLE QUOTATION MARK */ | |
| 554 | + { 0x0ad2, 0x201c }, /* leftdoublequotemark “ LEFT DOUBLE QUOTATION MARK */ | |
| 555 | + { 0x0ad3, 0x201d }, /* rightdoublequotemark ” RIGHT DOUBLE QUOTATION MARK */ | |
| 556 | + { 0x0ad4, 0x211e }, /* prescription ℞ PRESCRIPTION TAKE */ | |
| 557 | + { 0x0ad6, 0x2032 }, /* minutes ′ PRIME */ | |
| 558 | + { 0x0ad7, 0x2033 }, /* seconds ″ DOUBLE PRIME */ | |
| 559 | + { 0x0ad9, 0x271d }, /* latincross ✝ LATIN CROSS */ | |
| 560 | +/* 0x0ada hexagram ? ??? */ | |
| 561 | + { 0x0adb, 0x25ac }, /* filledrectbullet ▬ BLACK RECTANGLE */ | |
| 562 | + { 0x0adc, 0x25c0 }, /* filledlefttribullet ◀ BLACK LEFT-POINTING TRIANGLE */ | |
| 563 | + { 0x0add, 0x25b6 }, /* filledrighttribullet ▶ BLACK RIGHT-POINTING TRIANGLE */ | |
| 564 | + { 0x0ade, 0x25cf }, /* emfilledcircle ● BLACK CIRCLE */ | |
| 565 | + { 0x0adf, 0x25ae }, /* emfilledrect ▮ BLACK VERTICAL RECTANGLE */ | |
| 566 | + { 0x0ae0, 0x25e6 }, /* enopencircbullet ◦ WHITE BULLET */ | |
| 567 | + { 0x0ae1, 0x25ab }, /* enopensquarebullet ▫ WHITE SMALL SQUARE */ | |
| 568 | + { 0x0ae2, 0x25ad }, /* openrectbullet ▭ WHITE RECTANGLE */ | |
| 569 | + { 0x0ae3, 0x25b3 }, /* opentribulletup △ WHITE UP-POINTING TRIANGLE */ | |
| 570 | + { 0x0ae4, 0x25bd }, /* opentribulletdown ▽ WHITE DOWN-POINTING TRIANGLE */ | |
| 571 | + { 0x0ae5, 0x2606 }, /* openstar ☆ WHITE STAR */ | |
| 572 | + { 0x0ae6, 0x2022 }, /* enfilledcircbullet • BULLET */ | |
| 573 | + { 0x0ae7, 0x25aa }, /* enfilledsqbullet ▪ BLACK SMALL SQUARE */ | |
| 574 | + { 0x0ae8, 0x25b2 }, /* filledtribulletup ▲ BLACK UP-POINTING TRIANGLE */ | |
| 575 | + { 0x0ae9, 0x25bc }, /* filledtribulletdown ▼ BLACK DOWN-POINTING TRIANGLE */ | |
| 576 | + { 0x0aea, 0x261c }, /* leftpointer ☜ WHITE LEFT POINTING INDEX */ | |
| 577 | + { 0x0aeb, 0x261e }, /* rightpointer ☞ WHITE RIGHT POINTING INDEX */ | |
| 578 | + { 0x0aec, 0x2663 }, /* club ♣ BLACK CLUB SUIT */ | |
| 579 | + { 0x0aed, 0x2666 }, /* diamond ♦ BLACK DIAMOND SUIT */ | |
| 580 | + { 0x0aee, 0x2665 }, /* heart ♥ BLACK HEART SUIT */ | |
| 581 | + { 0x0af0, 0x2720 }, /* maltesecross ✠ MALTESE CROSS */ | |
| 582 | + { 0x0af1, 0x2020 }, /* dagger † DAGGER */ | |
| 583 | + { 0x0af2, 0x2021 }, /* doubledagger ‡ DOUBLE DAGGER */ | |
| 584 | + { 0x0af3, 0x2713 }, /* checkmark ✓ CHECK MARK */ | |
| 585 | + { 0x0af4, 0x2717 }, /* ballotcross ✗ BALLOT X */ | |
| 586 | + { 0x0af5, 0x266f }, /* musicalsharp ♯ MUSIC SHARP SIGN */ | |
| 587 | + { 0x0af6, 0x266d }, /* musicalflat ♭ MUSIC FLAT SIGN */ | |
| 588 | + { 0x0af7, 0x2642 }, /* malesymbol ♂ MALE SIGN */ | |
| 589 | + { 0x0af8, 0x2640 }, /* femalesymbol ♀ FEMALE SIGN */ | |
| 590 | + { 0x0af9, 0x260e }, /* telephone ☎ BLACK TELEPHONE */ | |
| 591 | + { 0x0afa, 0x2315 }, /* telephonerecorder ⌕ TELEPHONE RECORDER */ | |
| 592 | + { 0x0afb, 0x2117 }, /* phonographcopyright ℗ SOUND RECORDING COPYRIGHT */ | |
| 593 | + { 0x0afc, 0x2038 }, /* caret ‸ CARET */ | |
| 594 | + { 0x0afd, 0x201a }, /* singlelowquotemark ‚ SINGLE LOW-9 QUOTATION MARK */ | |
| 595 | + { 0x0afe, 0x201e }, /* doublelowquotemark „ DOUBLE LOW-9 QUOTATION MARK */ | |
| 596 | +/* 0x0aff cursor ? ??? */ | |
| 597 | + { 0x0ba3, 0x003c }, /* leftcaret < LESS-THAN SIGN */ | |
| 598 | + { 0x0ba6, 0x003e }, /* rightcaret > GREATER-THAN SIGN */ | |
| 599 | + { 0x0ba8, 0x2228 }, /* downcaret ∨ LOGICAL OR */ | |
| 600 | + { 0x0ba9, 0x2227 }, /* upcaret ∧ LOGICAL AND */ | |
| 601 | + { 0x0bc0, 0x00af }, /* overbar ¯ MACRON */ | |
| 602 | + { 0x0bc2, 0x22a5 }, /* downtack ⊥ UP TACK */ | |
| 603 | + { 0x0bc3, 0x2229 }, /* upshoe ∩ INTERSECTION */ | |
| 604 | + { 0x0bc4, 0x230a }, /* downstile ⌊ LEFT FLOOR */ | |
| 605 | + { 0x0bc6, 0x005f }, /* underbar _ LOW LINE */ | |
| 606 | + { 0x0bca, 0x2218 }, /* jot ∘ RING OPERATOR */ | |
| 607 | + { 0x0bcc, 0x2395 }, /* quad ⎕ APL FUNCTIONAL SYMBOL QUAD */ | |
| 608 | + { 0x0bce, 0x22a4 }, /* uptack ⊤ DOWN TACK */ | |
| 609 | + { 0x0bcf, 0x25cb }, /* circle ○ WHITE CIRCLE */ | |
| 610 | + { 0x0bd3, 0x2308 }, /* upstile ⌈ LEFT CEILING */ | |
| 611 | + { 0x0bd6, 0x222a }, /* downshoe ∪ UNION */ | |
| 612 | + { 0x0bd8, 0x2283 }, /* rightshoe ⊃ SUPERSET OF */ | |
| 613 | + { 0x0bda, 0x2282 }, /* leftshoe ⊂ SUBSET OF */ | |
| 614 | + { 0x0bdc, 0x22a2 }, /* lefttack ⊢ RIGHT TACK */ | |
| 615 | + { 0x0bfc, 0x22a3 }, /* righttack ⊣ LEFT TACK */ | |
| 616 | + { 0x0cdf, 0x2017 }, /* hebrew_doublelowline ‗ DOUBLE LOW LINE */ | |
| 617 | + { 0x0ce0, 0x05d0 }, /* hebrew_aleph א HEBREW LETTER ALEF */ | |
| 618 | + { 0x0ce1, 0x05d1 }, /* hebrew_bet ב HEBREW LETTER BET */ | |
| 619 | + { 0x0ce2, 0x05d2 }, /* hebrew_gimel ג HEBREW LETTER GIMEL */ | |
| 620 | + { 0x0ce3, 0x05d3 }, /* hebrew_dalet ד HEBREW LETTER DALET */ | |
| 621 | + { 0x0ce4, 0x05d4 }, /* hebrew_he ה HEBREW LETTER HE */ | |
| 622 | + { 0x0ce5, 0x05d5 }, /* hebrew_waw ו HEBREW LETTER VAV */ | |
| 623 | + { 0x0ce6, 0x05d6 }, /* hebrew_zain ז HEBREW LETTER ZAYIN */ | |
| 624 | + { 0x0ce7, 0x05d7 }, /* hebrew_chet ח HEBREW LETTER HET */ | |
| 625 | + { 0x0ce8, 0x05d8 }, /* hebrew_tet ט HEBREW LETTER TET */ | |
| 626 | + { 0x0ce9, 0x05d9 }, /* hebrew_yod י HEBREW LETTER YOD */ | |
| 627 | + { 0x0cea, 0x05da }, /* hebrew_finalkaph ך HEBREW LETTER FINAL KAF */ | |
| 628 | + { 0x0ceb, 0x05db }, /* hebrew_kaph כ HEBREW LETTER KAF */ | |
| 629 | + { 0x0cec, 0x05dc }, /* hebrew_lamed ל HEBREW LETTER LAMED */ | |
| 630 | + { 0x0ced, 0x05dd }, /* hebrew_finalmem ם HEBREW LETTER FINAL MEM */ | |
| 631 | + { 0x0cee, 0x05de }, /* hebrew_mem מ HEBREW LETTER MEM */ | |
| 632 | + { 0x0cef, 0x05df }, /* hebrew_finalnun ן HEBREW LETTER FINAL NUN */ | |
| 633 | + { 0x0cf0, 0x05e0 }, /* hebrew_nun נ HEBREW LETTER NUN */ | |
| 634 | + { 0x0cf1, 0x05e1 }, /* hebrew_samech ס HEBREW LETTER SAMEKH */ | |
| 635 | + { 0x0cf2, 0x05e2 }, /* hebrew_ayin ע HEBREW LETTER AYIN */ | |
| 636 | + { 0x0cf3, 0x05e3 }, /* hebrew_finalpe ף HEBREW LETTER FINAL PE */ | |
| 637 | + { 0x0cf4, 0x05e4 }, /* hebrew_pe פ HEBREW LETTER PE */ | |
| 638 | + { 0x0cf5, 0x05e5 }, /* hebrew_finalzade ץ HEBREW LETTER FINAL TSADI */ | |
| 639 | + { 0x0cf6, 0x05e6 }, /* hebrew_zade צ HEBREW LETTER TSADI */ | |
| 640 | + { 0x0cf7, 0x05e7 }, /* hebrew_qoph ק HEBREW LETTER QOF */ | |
| 641 | + { 0x0cf8, 0x05e8 }, /* hebrew_resh ר HEBREW LETTER RESH */ | |
| 642 | + { 0x0cf9, 0x05e9 }, /* hebrew_shin ש HEBREW LETTER SHIN */ | |
| 643 | + { 0x0cfa, 0x05ea }, /* hebrew_taw ת HEBREW LETTER TAV */ | |
| 644 | + { 0x0da1, 0x0e01 }, /* Thai_kokai ก THAI CHARACTER KO KAI */ | |
| 645 | + { 0x0da2, 0x0e02 }, /* Thai_khokhai ข THAI CHARACTER KHO KHAI */ | |
| 646 | + { 0x0da3, 0x0e03 }, /* Thai_khokhuat ฃ THAI CHARACTER KHO KHUAT */ | |
| 647 | + { 0x0da4, 0x0e04 }, /* Thai_khokhwai ค THAI CHARACTER KHO KHWAI */ | |
| 648 | + { 0x0da5, 0x0e05 }, /* Thai_khokhon ฅ THAI CHARACTER KHO KHON */ | |
| 649 | + { 0x0da6, 0x0e06 }, /* Thai_khorakhang ฆ THAI CHARACTER KHO RAKHANG */ | |
| 650 | + { 0x0da7, 0x0e07 }, /* Thai_ngongu ง THAI CHARACTER NGO NGU */ | |
| 651 | + { 0x0da8, 0x0e08 }, /* Thai_chochan จ THAI CHARACTER CHO CHAN */ | |
| 652 | + { 0x0da9, 0x0e09 }, /* Thai_choching ฉ THAI CHARACTER CHO CHING */ | |
| 653 | + { 0x0daa, 0x0e0a }, /* Thai_chochang ช THAI CHARACTER CHO CHANG */ | |
| 654 | + { 0x0dab, 0x0e0b }, /* Thai_soso ซ THAI CHARACTER SO SO */ | |
| 655 | + { 0x0dac, 0x0e0c }, /* Thai_chochoe ฌ THAI CHARACTER CHO CHOE */ | |
| 656 | + { 0x0dad, 0x0e0d }, /* Thai_yoying ญ THAI CHARACTER YO YING */ | |
| 657 | + { 0x0dae, 0x0e0e }, /* Thai_dochada ฎ THAI CHARACTER DO CHADA */ | |
| 658 | + { 0x0daf, 0x0e0f }, /* Thai_topatak ฏ THAI CHARACTER TO PATAK */ | |
| 659 | + { 0x0db0, 0x0e10 }, /* Thai_thothan ฐ THAI CHARACTER THO THAN */ | |
| 660 | + { 0x0db1, 0x0e11 }, /* Thai_thonangmontho ฑ THAI CHARACTER THO NANGMONTHO */ | |
| 661 | + { 0x0db2, 0x0e12 }, /* Thai_thophuthao ฒ THAI CHARACTER THO PHUTHAO */ | |
| 662 | + { 0x0db3, 0x0e13 }, /* Thai_nonen ณ THAI CHARACTER NO NEN */ | |
| 663 | + { 0x0db4, 0x0e14 }, /* Thai_dodek ด THAI CHARACTER DO DEK */ | |
| 664 | + { 0x0db5, 0x0e15 }, /* Thai_totao ต THAI CHARACTER TO TAO */ | |
| 665 | + { 0x0db6, 0x0e16 }, /* Thai_thothung ถ THAI CHARACTER THO THUNG */ | |
| 666 | + { 0x0db7, 0x0e17 }, /* Thai_thothahan ท THAI CHARACTER THO THAHAN */ | |
| 667 | + { 0x0db8, 0x0e18 }, /* Thai_thothong ธ THAI CHARACTER THO THONG */ | |
| 668 | + { 0x0db9, 0x0e19 }, /* Thai_nonu น THAI CHARACTER NO NU */ | |
| 669 | + { 0x0dba, 0x0e1a }, /* Thai_bobaimai บ THAI CHARACTER BO BAIMAI */ | |
| 670 | + { 0x0dbb, 0x0e1b }, /* Thai_popla ป THAI CHARACTER PO PLA */ | |
| 671 | + { 0x0dbc, 0x0e1c }, /* Thai_phophung ผ THAI CHARACTER PHO PHUNG */ | |
| 672 | + { 0x0dbd, 0x0e1d }, /* Thai_fofa ฝ THAI CHARACTER FO FA */ | |
| 673 | + { 0x0dbe, 0x0e1e }, /* Thai_phophan พ THAI CHARACTER PHO PHAN */ | |
| 674 | + { 0x0dbf, 0x0e1f }, /* Thai_fofan ฟ THAI CHARACTER FO FAN */ | |
| 675 | + { 0x0dc0, 0x0e20 }, /* Thai_phosamphao ภ THAI CHARACTER PHO SAMPHAO */ | |
| 676 | + { 0x0dc1, 0x0e21 }, /* Thai_moma ม THAI CHARACTER MO MA */ | |
| 677 | + { 0x0dc2, 0x0e22 }, /* Thai_yoyak ย THAI CHARACTER YO YAK */ | |
| 678 | + { 0x0dc3, 0x0e23 }, /* Thai_rorua ร THAI CHARACTER RO RUA */ | |
| 679 | + { 0x0dc4, 0x0e24 }, /* Thai_ru ฤ THAI CHARACTER RU */ | |
| 680 | + { 0x0dc5, 0x0e25 }, /* Thai_loling ล THAI CHARACTER LO LING */ | |
| 681 | + { 0x0dc6, 0x0e26 }, /* Thai_lu ฦ THAI CHARACTER LU */ | |
| 682 | + { 0x0dc7, 0x0e27 }, /* Thai_wowaen ว THAI CHARACTER WO WAEN */ | |
| 683 | + { 0x0dc8, 0x0e28 }, /* Thai_sosala ศ THAI CHARACTER SO SALA */ | |
| 684 | + { 0x0dc9, 0x0e29 }, /* Thai_sorusi ษ THAI CHARACTER SO RUSI */ | |
| 685 | + { 0x0dca, 0x0e2a }, /* Thai_sosua ส THAI CHARACTER SO SUA */ | |
| 686 | + { 0x0dcb, 0x0e2b }, /* Thai_hohip ห THAI CHARACTER HO HIP */ | |
| 687 | + { 0x0dcc, 0x0e2c }, /* Thai_lochula ฬ THAI CHARACTER LO CHULA */ | |
| 688 | + { 0x0dcd, 0x0e2d }, /* Thai_oang อ THAI CHARACTER O ANG */ | |
| 689 | + { 0x0dce, 0x0e2e }, /* Thai_honokhuk ฮ THAI CHARACTER HO NOKHUK */ | |
| 690 | + { 0x0dcf, 0x0e2f }, /* Thai_paiyannoi ฯ THAI CHARACTER PAIYANNOI */ | |
| 691 | + { 0x0dd0, 0x0e30 }, /* Thai_saraa ะ THAI CHARACTER SARA A */ | |
| 692 | + { 0x0dd1, 0x0e31 }, /* Thai_maihanakat ั THAI CHARACTER MAI HAN-AKAT */ | |
| 693 | + { 0x0dd2, 0x0e32 }, /* Thai_saraaa า THAI CHARACTER SARA AA */ | |
| 694 | + { 0x0dd3, 0x0e33 }, /* Thai_saraam ำ THAI CHARACTER SARA AM */ | |
| 695 | + { 0x0dd4, 0x0e34 }, /* Thai_sarai ิ THAI CHARACTER SARA I */ | |
| 696 | + { 0x0dd5, 0x0e35 }, /* Thai_saraii ี THAI CHARACTER SARA II */ | |
| 697 | + { 0x0dd6, 0x0e36 }, /* Thai_saraue ึ THAI CHARACTER SARA UE */ | |
| 698 | + { 0x0dd7, 0x0e37 }, /* Thai_sarauee ื THAI CHARACTER SARA UEE */ | |
| 699 | + { 0x0dd8, 0x0e38 }, /* Thai_sarau ุ THAI CHARACTER SARA U */ | |
| 700 | + { 0x0dd9, 0x0e39 }, /* Thai_sarauu ู THAI CHARACTER SARA UU */ | |
| 701 | + { 0x0dda, 0x0e3a }, /* Thai_phinthu ฺ THAI CHARACTER PHINTHU */ | |
| 702 | +/* 0x0dde Thai_maihanakat_maitho ? ??? */ | |
| 703 | + { 0x0ddf, 0x0e3f }, /* Thai_baht ฿ THAI CURRENCY SYMBOL BAHT */ | |
| 704 | + { 0x0de0, 0x0e40 }, /* Thai_sarae เ THAI CHARACTER SARA E */ | |
| 705 | + { 0x0de1, 0x0e41 }, /* Thai_saraae แ THAI CHARACTER SARA AE */ | |
| 706 | + { 0x0de2, 0x0e42 }, /* Thai_sarao โ THAI CHARACTER SARA O */ | |
| 707 | + { 0x0de3, 0x0e43 }, /* Thai_saraaimaimuan ใ THAI CHARACTER SARA AI MAIMUAN */ | |
| 708 | + { 0x0de4, 0x0e44 }, /* Thai_saraaimaimalai ไ THAI CHARACTER SARA AI MAIMALAI */ | |
| 709 | + { 0x0de5, 0x0e45 }, /* Thai_lakkhangyao ๅ THAI CHARACTER LAKKHANGYAO */ | |
| 710 | + { 0x0de6, 0x0e46 }, /* Thai_maiyamok ๆ THAI CHARACTER MAIYAMOK */ | |
| 711 | + { 0x0de7, 0x0e47 }, /* Thai_maitaikhu ็ THAI CHARACTER MAITAIKHU */ | |
| 712 | + { 0x0de8, 0x0e48 }, /* Thai_maiek ่ THAI CHARACTER MAI EK */ | |
| 713 | + { 0x0de9, 0x0e49 }, /* Thai_maitho ้ THAI CHARACTER MAI THO */ | |
| 714 | + { 0x0dea, 0x0e4a }, /* Thai_maitri ๊ THAI CHARACTER MAI TRI */ | |
| 715 | + { 0x0deb, 0x0e4b }, /* Thai_maichattawa ๋ THAI CHARACTER MAI CHATTAWA */ | |
| 716 | + { 0x0dec, 0x0e4c }, /* Thai_thanthakhat ์ THAI CHARACTER THANTHAKHAT */ | |
| 717 | + { 0x0ded, 0x0e4d }, /* Thai_nikhahit ํ THAI CHARACTER NIKHAHIT */ | |
| 718 | + { 0x0df0, 0x0e50 }, /* Thai_leksun ๐ THAI DIGIT ZERO */ | |
| 719 | + { 0x0df1, 0x0e51 }, /* Thai_leknung ๑ THAI DIGIT ONE */ | |
| 720 | + { 0x0df2, 0x0e52 }, /* Thai_leksong ๒ THAI DIGIT TWO */ | |
| 721 | + { 0x0df3, 0x0e53 }, /* Thai_leksam ๓ THAI DIGIT THREE */ | |
| 722 | + { 0x0df4, 0x0e54 }, /* Thai_leksi ๔ THAI DIGIT FOUR */ | |
| 723 | + { 0x0df5, 0x0e55 }, /* Thai_lekha ๕ THAI DIGIT FIVE */ | |
| 724 | + { 0x0df6, 0x0e56 }, /* Thai_lekhok ๖ THAI DIGIT SIX */ | |
| 725 | + { 0x0df7, 0x0e57 }, /* Thai_lekchet ๗ THAI DIGIT SEVEN */ | |
| 726 | + { 0x0df8, 0x0e58 }, /* Thai_lekpaet ๘ THAI DIGIT EIGHT */ | |
| 727 | + { 0x0df9, 0x0e59 }, /* Thai_lekkao ๙ THAI DIGIT NINE */ | |
| 728 | + { 0x0ea1, 0x3131 }, /* Hangul_Kiyeog ㄱ HANGUL LETTER KIYEOK */ | |
| 729 | + { 0x0ea2, 0x3132 }, /* Hangul_SsangKiyeog ㄲ HANGUL LETTER SSANGKIYEOK */ | |
| 730 | + { 0x0ea3, 0x3133 }, /* Hangul_KiyeogSios ㄳ HANGUL LETTER KIYEOK-SIOS */ | |
| 731 | + { 0x0ea4, 0x3134 }, /* Hangul_Nieun ㄴ HANGUL LETTER NIEUN */ | |
| 732 | + { 0x0ea5, 0x3135 }, /* Hangul_NieunJieuj ㄵ HANGUL LETTER NIEUN-CIEUC */ | |
| 733 | + { 0x0ea6, 0x3136 }, /* Hangul_NieunHieuh ㄶ HANGUL LETTER NIEUN-HIEUH */ | |
| 734 | + { 0x0ea7, 0x3137 }, /* Hangul_Dikeud ㄷ HANGUL LETTER TIKEUT */ | |
| 735 | + { 0x0ea8, 0x3138 }, /* Hangul_SsangDikeud ㄸ HANGUL LETTER SSANGTIKEUT */ | |
| 736 | + { 0x0ea9, 0x3139 }, /* Hangul_Rieul ㄹ HANGUL LETTER RIEUL */ | |
| 737 | + { 0x0eaa, 0x313a }, /* Hangul_RieulKiyeog ㄺ HANGUL LETTER RIEUL-KIYEOK */ | |
| 738 | + { 0x0eab, 0x313b }, /* Hangul_RieulMieum ㄻ HANGUL LETTER RIEUL-MIEUM */ | |
| 739 | + { 0x0eac, 0x313c }, /* Hangul_RieulPieub ㄼ HANGUL LETTER RIEUL-PIEUP */ | |
| 740 | + { 0x0ead, 0x313d }, /* Hangul_RieulSios ㄽ HANGUL LETTER RIEUL-SIOS */ | |
| 741 | + { 0x0eae, 0x313e }, /* Hangul_RieulTieut ㄾ HANGUL LETTER RIEUL-THIEUTH */ | |
| 742 | + { 0x0eaf, 0x313f }, /* Hangul_RieulPhieuf ㄿ HANGUL LETTER RIEUL-PHIEUPH */ | |
| 743 | + { 0x0eb0, 0x3140 }, /* Hangul_RieulHieuh ㅀ HANGUL LETTER RIEUL-HIEUH */ | |
| 744 | + { 0x0eb1, 0x3141 }, /* Hangul_Mieum ㅁ HANGUL LETTER MIEUM */ | |
| 745 | + { 0x0eb2, 0x3142 }, /* Hangul_Pieub ㅂ HANGUL LETTER PIEUP */ | |
| 746 | + { 0x0eb3, 0x3143 }, /* Hangul_SsangPieub ㅃ HANGUL LETTER SSANGPIEUP */ | |
| 747 | + { 0x0eb4, 0x3144 }, /* Hangul_PieubSios ㅄ HANGUL LETTER PIEUP-SIOS */ | |
| 748 | + { 0x0eb5, 0x3145 }, /* Hangul_Sios ㅅ HANGUL LETTER SIOS */ | |
| 749 | + { 0x0eb6, 0x3146 }, /* Hangul_SsangSios ㅆ HANGUL LETTER SSANGSIOS */ | |
| 750 | + { 0x0eb7, 0x3147 }, /* Hangul_Ieung ㅇ HANGUL LETTER IEUNG */ | |
| 751 | + { 0x0eb8, 0x3148 }, /* Hangul_Jieuj ㅈ HANGUL LETTER CIEUC */ | |
| 752 | + { 0x0eb9, 0x3149 }, /* Hangul_SsangJieuj ㅉ HANGUL LETTER SSANGCIEUC */ | |
| 753 | + { 0x0eba, 0x314a }, /* Hangul_Cieuc ㅊ HANGUL LETTER CHIEUCH */ | |
| 754 | + { 0x0ebb, 0x314b }, /* Hangul_Khieuq ㅋ HANGUL LETTER KHIEUKH */ | |
| 755 | + { 0x0ebc, 0x314c }, /* Hangul_Tieut ㅌ HANGUL LETTER THIEUTH */ | |
| 756 | + { 0x0ebd, 0x314d }, /* Hangul_Phieuf ㅍ HANGUL LETTER PHIEUPH */ | |
| 757 | + { 0x0ebe, 0x314e }, /* Hangul_Hieuh ㅎ HANGUL LETTER HIEUH */ | |
| 758 | + { 0x0ebf, 0x314f }, /* Hangul_A ㅏ HANGUL LETTER A */ | |
| 759 | + { 0x0ec0, 0x3150 }, /* Hangul_AE ㅐ HANGUL LETTER AE */ | |
| 760 | + { 0x0ec1, 0x3151 }, /* Hangul_YA ㅑ HANGUL LETTER YA */ | |
| 761 | + { 0x0ec2, 0x3152 }, /* Hangul_YAE ㅒ HANGUL LETTER YAE */ | |
| 762 | + { 0x0ec3, 0x3153 }, /* Hangul_EO ㅓ HANGUL LETTER EO */ | |
| 763 | + { 0x0ec4, 0x3154 }, /* Hangul_E ㅔ HANGUL LETTER E */ | |
| 764 | + { 0x0ec5, 0x3155 }, /* Hangul_YEO ㅕ HANGUL LETTER YEO */ | |
| 765 | + { 0x0ec6, 0x3156 }, /* Hangul_YE ㅖ HANGUL LETTER YE */ | |
| 766 | + { 0x0ec7, 0x3157 }, /* Hangul_O ㅗ HANGUL LETTER O */ | |
| 767 | + { 0x0ec8, 0x3158 }, /* Hangul_WA ㅘ HANGUL LETTER WA */ | |
| 768 | + { 0x0ec9, 0x3159 }, /* Hangul_WAE ㅙ HANGUL LETTER WAE */ | |
| 769 | + { 0x0eca, 0x315a }, /* Hangul_OE ㅚ HANGUL LETTER OE */ | |
| 770 | + { 0x0ecb, 0x315b }, /* Hangul_YO ㅛ HANGUL LETTER YO */ | |
| 771 | + { 0x0ecc, 0x315c }, /* Hangul_U ㅜ HANGUL LETTER U */ | |
| 772 | + { 0x0ecd, 0x315d }, /* Hangul_WEO ㅝ HANGUL LETTER WEO */ | |
| 773 | + { 0x0ece, 0x315e }, /* Hangul_WE ㅞ HANGUL LETTER WE */ | |
| 774 | + { 0x0ecf, 0x315f }, /* Hangul_WI ㅟ HANGUL LETTER WI */ | |
| 775 | + { 0x0ed0, 0x3160 }, /* Hangul_YU ㅠ HANGUL LETTER YU */ | |
| 776 | + { 0x0ed1, 0x3161 }, /* Hangul_EU ㅡ HANGUL LETTER EU */ | |
| 777 | + { 0x0ed2, 0x3162 }, /* Hangul_YI ㅢ HANGUL LETTER YI */ | |
| 778 | + { 0x0ed3, 0x3163 }, /* Hangul_I ㅣ HANGUL LETTER I */ | |
| 779 | + { 0x0ed4, 0x11a8 }, /* Hangul_J_Kiyeog ᆨ HANGUL JONGSEONG KIYEOK */ | |
| 780 | + { 0x0ed5, 0x11a9 }, /* Hangul_J_SsangKiyeog ᆩ HANGUL JONGSEONG SSANGKIYEOK */ | |
| 781 | + { 0x0ed6, 0x11aa }, /* Hangul_J_KiyeogSios ᆪ HANGUL JONGSEONG KIYEOK-SIOS */ | |
| 782 | + { 0x0ed7, 0x11ab }, /* Hangul_J_Nieun ᆫ HANGUL JONGSEONG NIEUN */ | |
| 783 | + { 0x0ed8, 0x11ac }, /* Hangul_J_NieunJieuj ᆬ HANGUL JONGSEONG NIEUN-CIEUC */ | |
| 784 | + { 0x0ed9, 0x11ad }, /* Hangul_J_NieunHieuh ᆭ HANGUL JONGSEONG NIEUN-HIEUH */ | |
| 785 | + { 0x0eda, 0x11ae }, /* Hangul_J_Dikeud ᆮ HANGUL JONGSEONG TIKEUT */ | |
| 786 | + { 0x0edb, 0x11af }, /* Hangul_J_Rieul ᆯ HANGUL JONGSEONG RIEUL */ | |
| 787 | + { 0x0edc, 0x11b0 }, /* Hangul_J_RieulKiyeog ᆰ HANGUL JONGSEONG RIEUL-KIYEOK */ | |
| 788 | + { 0x0edd, 0x11b1 }, /* Hangul_J_RieulMieum ᆱ HANGUL JONGSEONG RIEUL-MIEUM */ | |
| 789 | + { 0x0ede, 0x11b2 }, /* Hangul_J_RieulPieub ᆲ HANGUL JONGSEONG RIEUL-PIEUP */ | |
| 790 | + { 0x0edf, 0x11b3 }, /* Hangul_J_RieulSios ᆳ HANGUL JONGSEONG RIEUL-SIOS */ | |
| 791 | + { 0x0ee0, 0x11b4 }, /* Hangul_J_RieulTieut ᆴ HANGUL JONGSEONG RIEUL-THIEUTH */ | |
| 792 | + { 0x0ee1, 0x11b5 }, /* Hangul_J_RieulPhieuf ᆵ HANGUL JONGSEONG RIEUL-PHIEUPH */ | |
| 793 | + { 0x0ee2, 0x11b6 }, /* Hangul_J_RieulHieuh ᆶ HANGUL JONGSEONG RIEUL-HIEUH */ | |
| 794 | + { 0x0ee3, 0x11b7 }, /* Hangul_J_Mieum ᆷ HANGUL JONGSEONG MIEUM */ | |
| 795 | + { 0x0ee4, 0x11b8 }, /* Hangul_J_Pieub ᆸ HANGUL JONGSEONG PIEUP */ | |
| 796 | + { 0x0ee5, 0x11b9 }, /* Hangul_J_PieubSios ᆹ HANGUL JONGSEONG PIEUP-SIOS */ | |
| 797 | + { 0x0ee6, 0x11ba }, /* Hangul_J_Sios ᆺ HANGUL JONGSEONG SIOS */ | |
| 798 | + { 0x0ee7, 0x11bb }, /* Hangul_J_SsangSios ᆻ HANGUL JONGSEONG SSANGSIOS */ | |
| 799 | + { 0x0ee8, 0x11bc }, /* Hangul_J_Ieung ᆼ HANGUL JONGSEONG IEUNG */ | |
| 800 | + { 0x0ee9, 0x11bd }, /* Hangul_J_Jieuj ᆽ HANGUL JONGSEONG CIEUC */ | |
| 801 | + { 0x0eea, 0x11be }, /* Hangul_J_Cieuc ᆾ HANGUL JONGSEONG CHIEUCH */ | |
| 802 | + { 0x0eeb, 0x11bf }, /* Hangul_J_Khieuq ᆿ HANGUL JONGSEONG KHIEUKH */ | |
| 803 | + { 0x0eec, 0x11c0 }, /* Hangul_J_Tieut ᇀ HANGUL JONGSEONG THIEUTH */ | |
| 804 | + { 0x0eed, 0x11c1 }, /* Hangul_J_Phieuf ᇁ HANGUL JONGSEONG PHIEUPH */ | |
| 805 | + { 0x0eee, 0x11c2 }, /* Hangul_J_Hieuh ᇂ HANGUL JONGSEONG HIEUH */ | |
| 806 | + { 0x0eef, 0x316d }, /* Hangul_RieulYeorinHieuh ㅭ HANGUL LETTER RIEUL-YEORINHIEUH */ | |
| 807 | + { 0x0ef0, 0x3171 }, /* Hangul_SunkyeongeumMieum ㅱ HANGUL LETTER KAPYEOUNMIEUM */ | |
| 808 | + { 0x0ef1, 0x3178 }, /* Hangul_SunkyeongeumPieub ㅸ HANGUL LETTER KAPYEOUNPIEUP */ | |
| 809 | + { 0x0ef2, 0x317f }, /* Hangul_PanSios ㅿ HANGUL LETTER PANSIOS */ | |
| 810 | + { 0x0ef3, 0x3181 }, /* Hangul_KkogjiDalrinIeung ㆁ HANGUL LETTER YESIEUNG */ | |
| 811 | + { 0x0ef4, 0x3184 }, /* Hangul_SunkyeongeumPhieuf ㆄ HANGUL LETTER KAPYEOUNPHIEUPH */ | |
| 812 | + { 0x0ef5, 0x3186 }, /* Hangul_YeorinHieuh ㆆ HANGUL LETTER YEORINHIEUH */ | |
| 813 | + { 0x0ef6, 0x318d }, /* Hangul_AraeA ㆍ HANGUL LETTER ARAEA */ | |
| 814 | + { 0x0ef7, 0x318e }, /* Hangul_AraeAE ㆎ HANGUL LETTER ARAEAE */ | |
| 815 | + { 0x0ef8, 0x11eb }, /* Hangul_J_PanSios ᇫ HANGUL JONGSEONG PANSIOS */ | |
| 816 | + { 0x0ef9, 0x11f0 }, /* Hangul_J_KkogjiDalrinIeung ᇰ HANGUL JONGSEONG YESIEUNG */ | |
| 817 | + { 0x0efa, 0x11f9 }, /* Hangul_J_YeorinHieuh ᇹ HANGUL JONGSEONG YEORINHIEUH */ | |
| 818 | + { 0x0eff, 0x20a9 }, /* Korean_Won ₩ WON SIGN */ | |
| 819 | + { 0x13a4, 0x20ac }, /* Euro € EURO SIGN */ | |
| 820 | + { 0x13bc, 0x0152 }, /* OE ΠLATIN CAPITAL LIGATURE OE */ | |
| 821 | + { 0x13bd, 0x0153 }, /* oe œ LATIN SMALL LIGATURE OE */ | |
| 822 | + { 0x13be, 0x0178 }, /* Ydiaeresis Ÿ LATIN CAPITAL LETTER Y WITH DIAERESIS */ | |
| 823 | + { 0x20ac, 0x20ac }, /* EuroSign € EURO SIGN */ | |
| 824 | +}; | |
| 825 | + | |
| 826 | +VISIBLE | |
| 827 | +long keysym2ucs(KeySym keysym) | |
| 828 | +{ | |
| 829 | + int min = 0; | |
| 830 | + int max = sizeof(keysymtab) / sizeof(struct codepair) - 1; | |
| 831 | + int mid; | |
| 832 | + | |
| 833 | + /* first check for Latin-1 characters (1:1 mapping) */ | |
| 834 | + if ((keysym >= 0x0020 && keysym <= 0x007e) || | |
| 835 | + (keysym >= 0x00a0 && keysym <= 0x00ff)) | |
| 836 | + return keysym; | |
| 837 | + | |
| 838 | + /* also check for directly encoded 24-bit UCS characters */ | |
| 839 | + if ((keysym & 0xff000000) == 0x01000000) | |
| 840 | + return keysym & 0x00ffffff; | |
| 841 | + | |
| 842 | + /* binary search in table */ | |
| 843 | + while (max >= min) { | |
| 844 | + mid = (min + max) / 2; | |
| 845 | + if (keysymtab[mid].keysym < keysym) | |
| 846 | + min = mid + 1; | |
| 847 | + else if (keysymtab[mid].keysym > keysym) | |
| 848 | + max = mid - 1; | |
| 849 | + else { | |
| 850 | + /* found it */ | |
| 851 | + return keysymtab[mid].ucs; | |
| 852 | + } | |
| 853 | + } | |
| 854 | + | |
| 855 | + /* no matching Unicode value found */ | |
| 856 | + return -1; | |
| 857 | +} | |
| @@ -0,0 +1,9 @@ | ||
| 1 | +/* $XFree86: xc/programs/xterm/keysym2ucs.h,v 1.1 1999/06/12 15:37:18 dawes Exp $ */ | |
| 2 | +/* | |
| 3 | + * This module converts keysym values into the corresponding ISO 10646-1 | |
| 4 | + * (UCS, Unicode) values. | |
| 5 | + */ | |
| 6 | + | |
| 7 | +#include <X11/X.h> | |
| 8 | + | |
| 9 | +long keysym2ucs(KeySym keysym); | |
| @@ -0,0 +1,754 @@ | ||
| 1 | +static ulong | |
| 2 | +ksym2utf[] = { | |
| 3 | + [0x01a1] 0x0104, | |
| 4 | + [0x01a2] 0x02d8, | |
| 5 | + [0x01a3] 0x0141, | |
| 6 | + [0x01a5] 0x013d, | |
| 7 | + [0x01a6] 0x015a, | |
| 8 | + [0x01a9] 0x0160, | |
| 9 | + [0x01aa] 0x015e, | |
| 10 | + [0x01ab] 0x0164, | |
| 11 | + [0x01ac] 0x0179, | |
| 12 | + [0x01ae] 0x017d, | |
| 13 | + [0x01af] 0x017b, | |
| 14 | + [0x01b1] 0x0105, | |
| 15 | + [0x01b2] 0x02db, | |
| 16 | + [0x01b3] 0x0142, | |
| 17 | + [0x01b5] 0x013e, | |
| 18 | + [0x01b6] 0x015b, | |
| 19 | + [0x01b7] 0x02c7, | |
| 20 | + [0x01b9] 0x0161, | |
| 21 | + [0x01ba] 0x015f, | |
| 22 | + [0x01bb] 0x0165, | |
| 23 | + [0x01bc] 0x017a, | |
| 24 | + [0x01bd] 0x02dd, | |
| 25 | + [0x01be] 0x017e, | |
| 26 | + [0x01bf] 0x017c, | |
| 27 | + [0x01c0] 0x0154, | |
| 28 | + [0x01c3] 0x0102, | |
| 29 | + [0x01c5] 0x0139, | |
| 30 | + [0x01c6] 0x0106, | |
| 31 | + [0x01c8] 0x010c, | |
| 32 | + [0x01ca] 0x0118, | |
| 33 | + [0x01cc] 0x011a, | |
| 34 | + [0x01cf] 0x010e, | |
| 35 | + [0x01d0] 0x0110, | |
| 36 | + [0x01d1] 0x0143, | |
| 37 | + [0x01d2] 0x0147, | |
| 38 | + [0x01d5] 0x0150, | |
| 39 | + [0x01d8] 0x0158, | |
| 40 | + [0x01d9] 0x016e, | |
| 41 | + [0x01db] 0x0170, | |
| 42 | + [0x01de] 0x0162, | |
| 43 | + [0x01e0] 0x0155, | |
| 44 | + [0x01e3] 0x0103, | |
| 45 | + [0x01e5] 0x013a, | |
| 46 | + [0x01e6] 0x0107, | |
| 47 | + [0x01e8] 0x010d, | |
| 48 | + [0x01ea] 0x0119, | |
| 49 | + [0x01ec] 0x011b, | |
| 50 | + [0x01ef] 0x010f, | |
| 51 | + [0x01f0] 0x0111, | |
| 52 | + [0x01f1] 0x0144, | |
| 53 | + [0x01f2] 0x0148, | |
| 54 | + [0x01f5] 0x0151, | |
| 55 | + [0x01f8] 0x0159, | |
| 56 | + [0x01f9] 0x016f, | |
| 57 | + [0x01fb] 0x0171, | |
| 58 | + [0x01fe] 0x0163, | |
| 59 | + [0x01ff] 0x02d9, | |
| 60 | + [0x02a1] 0x0126, | |
| 61 | + [0x02a6] 0x0124, | |
| 62 | + [0x02a9] 0x0130, | |
| 63 | + [0x02ab] 0x011e, | |
| 64 | + [0x02ac] 0x0134, | |
| 65 | + [0x02b1] 0x0127, | |
| 66 | + [0x02b6] 0x0125, | |
| 67 | + [0x02b9] 0x0131, | |
| 68 | + [0x02bb] 0x011f, | |
| 69 | + [0x02bc] 0x0135, | |
| 70 | + [0x02c5] 0x010a, | |
| 71 | + [0x02c6] 0x0108, | |
| 72 | + [0x02d5] 0x0120, | |
| 73 | + [0x02d8] 0x011c, | |
| 74 | + [0x02dd] 0x016c, | |
| 75 | + [0x02de] 0x015c, | |
| 76 | + [0x02e5] 0x010b, | |
| 77 | + [0x02e6] 0x0109, | |
| 78 | + [0x02f5] 0x0121, | |
| 79 | + [0x02f8] 0x011d, | |
| 80 | + [0x02fd] 0x016d, | |
| 81 | + [0x02fe] 0x015d, | |
| 82 | + [0x03a2] 0x0138, | |
| 83 | + [0x03a3] 0x0156, | |
| 84 | + [0x03a5] 0x0128, | |
| 85 | + [0x03a6] 0x013b, | |
| 86 | + [0x03aa] 0x0112, | |
| 87 | + [0x03ab] 0x0122, | |
| 88 | + [0x03ac] 0x0166, | |
| 89 | + [0x03b3] 0x0157, | |
| 90 | + [0x03b5] 0x0129, | |
| 91 | + [0x03b6] 0x013c, | |
| 92 | + [0x03ba] 0x0113, | |
| 93 | + [0x03bb] 0x0123, | |
| 94 | + [0x03bc] 0x0167, | |
| 95 | + [0x03bd] 0x014a, | |
| 96 | + [0x03bf] 0x014b, | |
| 97 | + [0x03c0] 0x0100, | |
| 98 | + [0x03c7] 0x012e, | |
| 99 | + [0x03cc] 0x0116, | |
| 100 | + [0x03cf] 0x012a, | |
| 101 | + [0x03d1] 0x0145, | |
| 102 | + [0x03d2] 0x014c, | |
| 103 | + [0x03d3] 0x0136, | |
| 104 | + [0x03d9] 0x0172, | |
| 105 | + [0x03dd] 0x0168, | |
| 106 | + [0x03de] 0x016a, | |
| 107 | + [0x03e0] 0x0101, | |
| 108 | + [0x03e7] 0x012f, | |
| 109 | + [0x03ec] 0x0117, | |
| 110 | + [0x03ef] 0x012b, | |
| 111 | + [0x03f1] 0x0146, | |
| 112 | + [0x03f2] 0x014d, | |
| 113 | + [0x03f3] 0x0137, | |
| 114 | + [0x03f9] 0x0173, | |
| 115 | + [0x03fd] 0x0169, | |
| 116 | + [0x03fe] 0x016b, | |
| 117 | + [0x047e] 0x203e, | |
| 118 | + [0x04a1] 0x3002, | |
| 119 | + [0x04a2] 0x300c, | |
| 120 | + [0x04a3] 0x300d, | |
| 121 | + [0x04a4] 0x3001, | |
| 122 | + [0x04a5] 0x30fb, | |
| 123 | + [0x04a6] 0x30f2, | |
| 124 | + [0x04a7] 0x30a1, | |
| 125 | + [0x04a8] 0x30a3, | |
| 126 | + [0x04a9] 0x30a5, | |
| 127 | + [0x04aa] 0x30a7, | |
| 128 | + [0x04ab] 0x30a9, | |
| 129 | + [0x04ac] 0x30e3, | |
| 130 | + [0x04ad] 0x30e5, | |
| 131 | + [0x04ae] 0x30e7, | |
| 132 | + [0x04af] 0x30c3, | |
| 133 | + [0x04b0] 0x30fc, | |
| 134 | + [0x04b1] 0x30a2, | |
| 135 | + [0x04b2] 0x30a4, | |
| 136 | + [0x04b3] 0x30a6, | |
| 137 | + [0x04b4] 0x30a8, | |
| 138 | + [0x04b5] 0x30aa, | |
| 139 | + [0x04b6] 0x30ab, | |
| 140 | + [0x04b7] 0x30ad, | |
| 141 | + [0x04b8] 0x30af, | |
| 142 | + [0x04b9] 0x30b1, | |
| 143 | + [0x04ba] 0x30b3, | |
| 144 | + [0x04bb] 0x30b5, | |
| 145 | + [0x04bc] 0x30b7, | |
| 146 | + [0x04bd] 0x30b9, | |
| 147 | + [0x04be] 0x30bb, | |
| 148 | + [0x04bf] 0x30bd, | |
| 149 | + [0x04c0] 0x30bf, | |
| 150 | + [0x04c1] 0x30c1, | |
| 151 | + [0x04c2] 0x30c4, | |
| 152 | + [0x04c3] 0x30c6, | |
| 153 | + [0x04c4] 0x30c8, | |
| 154 | + [0x04c5] 0x30ca, | |
| 155 | + [0x04c6] 0x30cb, | |
| 156 | + [0x04c7] 0x30cc, | |
| 157 | + [0x04c8] 0x30cd, | |
| 158 | + [0x04c9] 0x30ce, | |
| 159 | + [0x04ca] 0x30cf, | |
| 160 | + [0x04cb] 0x30d2, | |
| 161 | + [0x04cc] 0x30d5, | |
| 162 | + [0x04cd] 0x30d8, | |
| 163 | + [0x04ce] 0x30db, | |
| 164 | + [0x04cf] 0x30de, | |
| 165 | + [0x04d0] 0x30df, | |
| 166 | + [0x04d1] 0x30e0, | |
| 167 | + [0x04d2] 0x30e1, | |
| 168 | + [0x04d3] 0x30e2, | |
| 169 | + [0x04d4] 0x30e4, | |
| 170 | + [0x04d5] 0x30e6, | |
| 171 | + [0x04d6] 0x30e8, | |
| 172 | + [0x04d7] 0x30e9, | |
| 173 | + [0x04d8] 0x30ea, | |
| 174 | + [0x04d9] 0x30eb, | |
| 175 | + [0x04da] 0x30ec, | |
| 176 | + [0x04db] 0x30ed, | |
| 177 | + [0x04dc] 0x30ef, | |
| 178 | + [0x04dd] 0x30f3, | |
| 179 | + [0x04de] 0x309b, | |
| 180 | + [0x04df] 0x309c, | |
| 181 | + [0x05ac] 0x060c, | |
| 182 | + [0x05bb] 0x061b, | |
| 183 | + [0x05bf] 0x061f, | |
| 184 | + [0x05c1] 0x0621, | |
| 185 | + [0x05c2] 0x0622, | |
| 186 | + [0x05c3] 0x0623, | |
| 187 | + [0x05c4] 0x0624, | |
| 188 | + [0x05c5] 0x0625, | |
| 189 | + [0x05c6] 0x0626, | |
| 190 | + [0x05c7] 0x0627, | |
| 191 | + [0x05c8] 0x0628, | |
| 192 | + [0x05c9] 0x0629, | |
| 193 | + [0x05ca] 0x062a, | |
| 194 | + [0x05cb] 0x062b, | |
| 195 | + [0x05cc] 0x062c, | |
| 196 | + [0x05cd] 0x062d, | |
| 197 | + [0x05ce] 0x062e, | |
| 198 | + [0x05cf] 0x062f, | |
| 199 | + [0x05d0] 0x0630, | |
| 200 | + [0x05d1] 0x0631, | |
| 201 | + [0x05d2] 0x0632, | |
| 202 | + [0x05d3] 0x0633, | |
| 203 | + [0x05d4] 0x0634, | |
| 204 | + [0x05d5] 0x0635, | |
| 205 | + [0x05d6] 0x0636, | |
| 206 | + [0x05d7] 0x0637, | |
| 207 | + [0x05d8] 0x0638, | |
| 208 | + [0x05d9] 0x0639, | |
| 209 | + [0x05da] 0x063a, | |
| 210 | + [0x05e0] 0x0640, | |
| 211 | + [0x05e1] 0x0641, | |
| 212 | + [0x05e2] 0x0642, | |
| 213 | + [0x05e3] 0x0643, | |
| 214 | + [0x05e4] 0x0644, | |
| 215 | + [0x05e5] 0x0645, | |
| 216 | + [0x05e6] 0x0646, | |
| 217 | + [0x05e7] 0x0647, | |
| 218 | + [0x05e8] 0x0648, | |
| 219 | + [0x05e9] 0x0649, | |
| 220 | + [0x05ea] 0x064a, | |
| 221 | + [0x05eb] 0x064b, | |
| 222 | + [0x05ec] 0x064c, | |
| 223 | + [0x05ed] 0x064d, | |
| 224 | + [0x05ee] 0x064e, | |
| 225 | + [0x05ef] 0x064f, | |
| 226 | + [0x05f0] 0x0650, | |
| 227 | + [0x05f1] 0x0651, | |
| 228 | + [0x05f2] 0x0652, | |
| 229 | + [0x06a1] 0x0452, | |
| 230 | + [0x06a2] 0x0453, | |
| 231 | + [0x06a3] 0x0451, | |
| 232 | + [0x06a4] 0x0454, | |
| 233 | + [0x06a5] 0x0455, | |
| 234 | + [0x06a6] 0x0456, | |
| 235 | + [0x06a7] 0x0457, | |
| 236 | + [0x06a8] 0x0458, | |
| 237 | + [0x06a9] 0x0459, | |
| 238 | + [0x06aa] 0x045a, | |
| 239 | + [0x06ab] 0x045b, | |
| 240 | + [0x06ac] 0x045c, | |
| 241 | + [0x06ae] 0x045e, | |
| 242 | + [0x06af] 0x045f, | |
| 243 | + [0x06b0] 0x2116, | |
| 244 | + [0x06b1] 0x0402, | |
| 245 | + [0x06b2] 0x0403, | |
| 246 | + [0x06b3] 0x0401, | |
| 247 | + [0x06b4] 0x0404, | |
| 248 | + [0x06b5] 0x0405, | |
| 249 | + [0x06b6] 0x0406, | |
| 250 | + [0x06b7] 0x0407, | |
| 251 | + [0x06b8] 0x0408, | |
| 252 | + [0x06b9] 0x0409, | |
| 253 | + [0x06ba] 0x040a, | |
| 254 | + [0x06bb] 0x040b, | |
| 255 | + [0x06bc] 0x040c, | |
| 256 | + [0x06be] 0x040e, | |
| 257 | + [0x06bf] 0x040f, | |
| 258 | + [0x06c0] 0x044e, | |
| 259 | + [0x06c1] 0x0430, | |
| 260 | + [0x06c2] 0x0431, | |
| 261 | + [0x06c3] 0x0446, | |
| 262 | + [0x06c4] 0x0434, | |
| 263 | + [0x06c5] 0x0435, | |
| 264 | + [0x06c6] 0x0444, | |
| 265 | + [0x06c7] 0x0433, | |
| 266 | + [0x06c8] 0x0445, | |
| 267 | + [0x06c9] 0x0438, | |
| 268 | + [0x06ca] 0x0439, | |
| 269 | + [0x06cb] 0x043a, | |
| 270 | + [0x06cc] 0x043b, | |
| 271 | + [0x06cd] 0x043c, | |
| 272 | + [0x06ce] 0x043d, | |
| 273 | + [0x06cf] 0x043e, | |
| 274 | + [0x06d0] 0x043f, | |
| 275 | + [0x06d1] 0x044f, | |
| 276 | + [0x06d2] 0x0440, | |
| 277 | + [0x06d3] 0x0441, | |
| 278 | + [0x06d4] 0x0442, | |
| 279 | + [0x06d5] 0x0443, | |
| 280 | + [0x06d6] 0x0436, | |
| 281 | + [0x06d7] 0x0432, | |
| 282 | + [0x06d8] 0x044c, | |
| 283 | + [0x06d9] 0x044b, | |
| 284 | + [0x06da] 0x0437, | |
| 285 | + [0x06db] 0x0448, | |
| 286 | + [0x06dc] 0x044d, | |
| 287 | + [0x06dd] 0x0449, | |
| 288 | + [0x06de] 0x0447, | |
| 289 | + [0x06df] 0x044a, | |
| 290 | + [0x06e0] 0x042e, | |
| 291 | + [0x06e1] 0x0410, | |
| 292 | + [0x06e2] 0x0411, | |
| 293 | + [0x06e3] 0x0426, | |
| 294 | + [0x06e4] 0x0414, | |
| 295 | + [0x06e5] 0x0415, | |
| 296 | + [0x06e6] 0x0424, | |
| 297 | + [0x06e7] 0x0413, | |
| 298 | + [0x06e8] 0x0425, | |
| 299 | + [0x06e9] 0x0418, | |
| 300 | + [0x06ea] 0x0419, | |
| 301 | + [0x06eb] 0x041a, | |
| 302 | + [0x06ec] 0x041b, | |
| 303 | + [0x06ed] 0x041c, | |
| 304 | + [0x06ee] 0x041d, | |
| 305 | + [0x06ef] 0x041e, | |
| 306 | + [0x06f0] 0x041f, | |
| 307 | + [0x06f1] 0x042f, | |
| 308 | + [0x06f2] 0x0420, | |
| 309 | + [0x06f3] 0x0421, | |
| 310 | + [0x06f4] 0x0422, | |
| 311 | + [0x06f5] 0x0423, | |
| 312 | + [0x06f6] 0x0416, | |
| 313 | + [0x06f7] 0x0412, | |
| 314 | + [0x06f8] 0x042c, | |
| 315 | + [0x06f9] 0x042b, | |
| 316 | + [0x06fa] 0x0417, | |
| 317 | + [0x06fb] 0x0428, | |
| 318 | + [0x06fc] 0x042d, | |
| 319 | + [0x06fd] 0x0429, | |
| 320 | + [0x06fe] 0x0427, | |
| 321 | + [0x06ff] 0x042a, | |
| 322 | + [0x07a1] 0x0386, | |
| 323 | + [0x07a2] 0x0388, | |
| 324 | + [0x07a3] 0x0389, | |
| 325 | + [0x07a4] 0x038a, | |
| 326 | + [0x07a5] 0x03aa, | |
| 327 | + [0x07a7] 0x038c, | |
| 328 | + [0x07a8] 0x038e, | |
| 329 | + [0x07a9] 0x03ab, | |
| 330 | + [0x07ab] 0x038f, | |
| 331 | + [0x07ae] 0x0385, | |
| 332 | + [0x07af] 0x2015, | |
| 333 | + [0x07b1] 0x03ac, | |
| 334 | + [0x07b2] 0x03ad, | |
| 335 | + [0x07b3] 0x03ae, | |
| 336 | + [0x07b4] 0x03af, | |
| 337 | + [0x07b5] 0x03ca, | |
| 338 | + [0x07b6] 0x0390, | |
| 339 | + [0x07b7] 0x03cc, | |
| 340 | + [0x07b8] 0x03cd, | |
| 341 | + [0x07b9] 0x03cb, | |
| 342 | + [0x07ba] 0x03b0, | |
| 343 | + [0x07bb] 0x03ce, | |
| 344 | + [0x07c1] 0x0391, | |
| 345 | + [0x07c2] 0x0392, | |
| 346 | + [0x07c3] 0x0393, | |
| 347 | + [0x07c4] 0x0394, | |
| 348 | + [0x07c5] 0x0395, | |
| 349 | + [0x07c6] 0x0396, | |
| 350 | + [0x07c7] 0x0397, | |
| 351 | + [0x07c8] 0x0398, | |
| 352 | + [0x07c9] 0x0399, | |
| 353 | + [0x07ca] 0x039a, | |
| 354 | + [0x07cb] 0x039b, | |
| 355 | + [0x07cc] 0x039c, | |
| 356 | + [0x07cd] 0x039d, | |
| 357 | + [0x07ce] 0x039e, | |
| 358 | + [0x07cf] 0x039f, | |
| 359 | + [0x07d0] 0x03a0, | |
| 360 | + [0x07d1] 0x03a1, | |
| 361 | + [0x07d2] 0x03a3, | |
| 362 | + [0x07d4] 0x03a4, | |
| 363 | + [0x07d5] 0x03a5, | |
| 364 | + [0x07d6] 0x03a6, | |
| 365 | + [0x07d7] 0x03a7, | |
| 366 | + [0x07d8] 0x03a8, | |
| 367 | + [0x07d9] 0x03a9, | |
| 368 | + [0x07e1] 0x03b1, | |
| 369 | + [0x07e2] 0x03b2, | |
| 370 | + [0x07e3] 0x03b3, | |
| 371 | + [0x07e4] 0x03b4, | |
| 372 | + [0x07e5] 0x03b5, | |
| 373 | + [0x07e6] 0x03b6, | |
| 374 | + [0x07e7] 0x03b7, | |
| 375 | + [0x07e8] 0x03b8, | |
| 376 | + [0x07e9] 0x03b9, | |
| 377 | + [0x07ea] 0x03ba, | |
| 378 | + [0x07eb] 0x03bb, | |
| 379 | + [0x07ec] 0x03bc, | |
| 380 | + [0x07ed] 0x03bd, | |
| 381 | + [0x07ee] 0x03be, | |
| 382 | + [0x07ef] 0x03bf, | |
| 383 | + [0x07f0] 0x03c0, | |
| 384 | + [0x07f1] 0x03c1, | |
| 385 | + [0x07f2] 0x03c3, | |
| 386 | + [0x07f3] 0x03c2, | |
| 387 | + [0x07f4] 0x03c4, | |
| 388 | + [0x07f5] 0x03c5, | |
| 389 | + [0x07f6] 0x03c6, | |
| 390 | + [0x07f7] 0x03c7, | |
| 391 | + [0x07f8] 0x03c8, | |
| 392 | + [0x07f9] 0x03c9, | |
| 393 | + [0x08a4] 0x2320, | |
| 394 | + [0x08a5] 0x2321, | |
| 395 | + [0x08a6] 0x2502, | |
| 396 | + [0x08bc] 0x2264, | |
| 397 | + [0x08bd] 0x2260, | |
| 398 | + [0x08be] 0x2265, | |
| 399 | + [0x08bf] 0x222b, | |
| 400 | + [0x08c0] 0x2234, | |
| 401 | + [0x08c1] 0x221d, | |
| 402 | + [0x08c2] 0x221e, | |
| 403 | + [0x08c5] 0x2207, | |
| 404 | + [0x08c8] 0x2245, | |
| 405 | + [0x08cd] 0x21d4, | |
| 406 | + [0x08ce] 0x21d2, | |
| 407 | + [0x08cf] 0x2261, | |
| 408 | + [0x08d6] 0x221a, | |
| 409 | + [0x08da] 0x2282, | |
| 410 | + [0x08db] 0x2283, | |
| 411 | + [0x08dc] 0x2229, | |
| 412 | + [0x08dd] 0x222a, | |
| 413 | + [0x08de] 0x2227, | |
| 414 | + [0x08df] 0x2228, | |
| 415 | + [0x08ef] 0x2202, | |
| 416 | + [0x08f6] 0x0192, | |
| 417 | + [0x08fb] 0x2190, | |
| 418 | + [0x08fc] 0x2191, | |
| 419 | + [0x08fd] 0x2192, | |
| 420 | + [0x08fe] 0x2193, | |
| 421 | + [0x09df] 0x2422, | |
| 422 | + [0x09e0] 0x25c6, | |
| 423 | + [0x09e1] 0x2592, | |
| 424 | + [0x09e2] 0x2409, | |
| 425 | + [0x09e3] 0x240c, | |
| 426 | + [0x09e4] 0x240d, | |
| 427 | + [0x09e5] 0x240a, | |
| 428 | + [0x09e8] 0x2424, | |
| 429 | + [0x09e9] 0x240b, | |
| 430 | + [0x09ea] 0x2518, | |
| 431 | + [0x09eb] 0x2510, | |
| 432 | + [0x09ec] 0x250c, | |
| 433 | + [0x09ed] 0x2514, | |
| 434 | + [0x09ee] 0x253c, | |
| 435 | + [0x09f1] 0x2500, | |
| 436 | + [0x09f4] 0x251c, | |
| 437 | + [0x09f5] 0x2524, | |
| 438 | + [0x09f6] 0x2534, | |
| 439 | + [0x09f7] 0x252c, | |
| 440 | + [0x09f8] 0x2502, | |
| 441 | + [0x0aa1] 0x2003, | |
| 442 | + [0x0aa2] 0x2002, | |
| 443 | + [0x0aa3] 0x2004, | |
| 444 | + [0x0aa4] 0x2005, | |
| 445 | + [0x0aa5] 0x2007, | |
| 446 | + [0x0aa6] 0x2008, | |
| 447 | + [0x0aa7] 0x2009, | |
| 448 | + [0x0aa8] 0x200a, | |
| 449 | + [0x0aa9] 0x2014, | |
| 450 | + [0x0aaa] 0x2013, | |
| 451 | + [0x0aae] 0x2026, | |
| 452 | + [0x0ab0] 0x2153, | |
| 453 | + [0x0ab1] 0x2154, | |
| 454 | + [0x0ab2] 0x2155, | |
| 455 | + [0x0ab3] 0x2156, | |
| 456 | + [0x0ab4] 0x2157, | |
| 457 | + [0x0ab5] 0x2158, | |
| 458 | + [0x0ab6] 0x2159, | |
| 459 | + [0x0ab7] 0x215a, | |
| 460 | + [0x0ab8] 0x2105, | |
| 461 | + [0x0abb] 0x2012, | |
| 462 | + [0x0abc] 0x2329, | |
| 463 | + [0x0abd] 0x002e, | |
| 464 | + [0x0abe] 0x232a, | |
| 465 | + [0x0ac3] 0x215b, | |
| 466 | + [0x0ac4] 0x215c, | |
| 467 | + [0x0ac5] 0x215d, | |
| 468 | + [0x0ac6] 0x215e, | |
| 469 | + [0x0ac9] 0x2122, | |
| 470 | + [0x0aca] 0x2613, | |
| 471 | + [0x0acc] 0x25c1, | |
| 472 | + [0x0acd] 0x25b7, | |
| 473 | + [0x0ace] 0x25cb, | |
| 474 | + [0x0acf] 0x25a1, | |
| 475 | + [0x0ad0] 0x2018, | |
| 476 | + [0x0ad1] 0x2019, | |
| 477 | + [0x0ad2] 0x201c, | |
| 478 | + [0x0ad3] 0x201d, | |
| 479 | + [0x0ad4] 0x211e, | |
| 480 | + [0x0ad6] 0x2032, | |
| 481 | + [0x0ad7] 0x2033, | |
| 482 | + [0x0ad9] 0x271d, | |
| 483 | + [0x0adb] 0x25ac, | |
| 484 | + [0x0adc] 0x25c0, | |
| 485 | + [0x0add] 0x25b6, | |
| 486 | + [0x0ade] 0x25cf, | |
| 487 | + [0x0adf] 0x25a0, | |
| 488 | + [0x0ae0] 0x25e6, | |
| 489 | + [0x0ae1] 0x25ab, | |
| 490 | + [0x0ae2] 0x25ad, | |
| 491 | + [0x0ae3] 0x25b3, | |
| 492 | + [0x0ae4] 0x25bd, | |
| 493 | + [0x0ae5] 0x2606, | |
| 494 | + [0x0ae6] 0x2022, | |
| 495 | + [0x0ae7] 0x25aa, | |
| 496 | + [0x0ae8] 0x25b2, | |
| 497 | + [0x0ae9] 0x25bc, | |
| 498 | + [0x0aea] 0x261c, | |
| 499 | + [0x0aeb] 0x261e, | |
| 500 | + [0x0aec] 0x2663, | |
| 501 | + [0x0aed] 0x2666, | |
| 502 | + [0x0aee] 0x2665, | |
| 503 | + [0x0af0] 0x2720, | |
| 504 | + [0x0af1] 0x2020, | |
| 505 | + [0x0af2] 0x2021, | |
| 506 | + [0x0af3] 0x2713, | |
| 507 | + [0x0af4] 0x2717, | |
| 508 | + [0x0af5] 0x266f, | |
| 509 | + [0x0af6] 0x266d, | |
| 510 | + [0x0af7] 0x2642, | |
| 511 | + [0x0af8] 0x2640, | |
| 512 | + [0x0af9] 0x260e, | |
| 513 | + [0x0afa] 0x2315, | |
| 514 | + [0x0afb] 0x2117, | |
| 515 | + [0x0afc] 0x2038, | |
| 516 | + [0x0afd] 0x201a, | |
| 517 | + [0x0afe] 0x201e, | |
| 518 | + [0x0ba3] 0x003c, | |
| 519 | + [0x0ba6] 0x003e, | |
| 520 | + [0x0ba8] 0x2228, | |
| 521 | + [0x0ba9] 0x2227, | |
| 522 | + [0x0bc0] 0x00af, | |
| 523 | + [0x0bc2] 0x22a4, | |
| 524 | + [0x0bc3] 0x2229, | |
| 525 | + [0x0bc4] 0x230a, | |
| 526 | + [0x0bc6] 0x005f, | |
| 527 | + [0x0bca] 0x2218, | |
| 528 | + [0x0bcc] 0x2395, | |
| 529 | + [0x0bce] 0x22a5, | |
| 530 | + [0x0bcf] 0x25cb, | |
| 531 | + [0x0bd3] 0x2308, | |
| 532 | + [0x0bd6] 0x222a, | |
| 533 | + [0x0bd8] 0x2283, | |
| 534 | + [0x0bda] 0x2282, | |
| 535 | + [0x0bdc] 0x22a3, | |
| 536 | + [0x0bfc] 0x22a2, | |
| 537 | + [0x0cdf] 0x2017, | |
| 538 | + [0x0ce0] 0x05d0, | |
| 539 | + [0x0ce1] 0x05d1, | |
| 540 | + [0x0ce2] 0x05d2, | |
| 541 | + [0x0ce3] 0x05d3, | |
| 542 | + [0x0ce4] 0x05d4, | |
| 543 | + [0x0ce5] 0x05d5, | |
| 544 | + [0x0ce6] 0x05d6, | |
| 545 | + [0x0ce7] 0x05d7, | |
| 546 | + [0x0ce8] 0x05d8, | |
| 547 | + [0x0ce9] 0x05d9, | |
| 548 | + [0x0cea] 0x05da, | |
| 549 | + [0x0ceb] 0x05db, | |
| 550 | + [0x0cec] 0x05dc, | |
| 551 | + [0x0ced] 0x05dd, | |
| 552 | + [0x0cee] 0x05de, | |
| 553 | + [0x0cef] 0x05df, | |
| 554 | + [0x0cf0] 0x05e0, | |
| 555 | + [0x0cf1] 0x05e1, | |
| 556 | + [0x0cf2] 0x05e2, | |
| 557 | + [0x0cf3] 0x05e3, | |
| 558 | + [0x0cf4] 0x05e4, | |
| 559 | + [0x0cf5] 0x05e5, | |
| 560 | + [0x0cf6] 0x05e6, | |
| 561 | + [0x0cf7] 0x05e7, | |
| 562 | + [0x0cf8] 0x05e8, | |
| 563 | + [0x0cf9] 0x05e9, | |
| 564 | + [0x0cfa] 0x05ea, | |
| 565 | + [0x0da1] 0x0e01, | |
| 566 | + [0x0da2] 0x0e02, | |
| 567 | + [0x0da3] 0x0e03, | |
| 568 | + [0x0da4] 0x0e04, | |
| 569 | + [0x0da5] 0x0e05, | |
| 570 | + [0x0da6] 0x0e06, | |
| 571 | + [0x0da7] 0x0e07, | |
| 572 | + [0x0da8] 0x0e08, | |
| 573 | + [0x0da9] 0x0e09, | |
| 574 | + [0x0daa] 0x0e0a, | |
| 575 | + [0x0dab] 0x0e0b, | |
| 576 | + [0x0dac] 0x0e0c, | |
| 577 | + [0x0dad] 0x0e0d, | |
| 578 | + [0x0dae] 0x0e0e, | |
| 579 | + [0x0daf] 0x0e0f, | |
| 580 | + [0x0db0] 0x0e10, | |
| 581 | + [0x0db1] 0x0e11, | |
| 582 | + [0x0db2] 0x0e12, | |
| 583 | + [0x0db3] 0x0e13, | |
| 584 | + [0x0db4] 0x0e14, | |
| 585 | + [0x0db5] 0x0e15, | |
| 586 | + [0x0db6] 0x0e16, | |
| 587 | + [0x0db7] 0x0e17, | |
| 588 | + [0x0db8] 0x0e18, | |
| 589 | + [0x0db9] 0x0e19, | |
| 590 | + [0x0dba] 0x0e1a, | |
| 591 | + [0x0dbb] 0x0e1b, | |
| 592 | + [0x0dbc] 0x0e1c, | |
| 593 | + [0x0dbd] 0x0e1d, | |
| 594 | + [0x0dbe] 0x0e1e, | |
| 595 | + [0x0dbf] 0x0e1f, | |
| 596 | + [0x0dc0] 0x0e20, | |
| 597 | + [0x0dc1] 0x0e21, | |
| 598 | + [0x0dc2] 0x0e22, | |
| 599 | + [0x0dc3] 0x0e23, | |
| 600 | + [0x0dc4] 0x0e24, | |
| 601 | + [0x0dc5] 0x0e25, | |
| 602 | + [0x0dc6] 0x0e26, | |
| 603 | + [0x0dc7] 0x0e27, | |
| 604 | + [0x0dc8] 0x0e28, | |
| 605 | + [0x0dc9] 0x0e29, | |
| 606 | + [0x0dca] 0x0e2a, | |
| 607 | + [0x0dcb] 0x0e2b, | |
| 608 | + [0x0dcc] 0x0e2c, | |
| 609 | + [0x0dcd] 0x0e2d, | |
| 610 | + [0x0dce] 0x0e2e, | |
| 611 | + [0x0dcf] 0x0e2f, | |
| 612 | + [0x0dd0] 0x0e30, | |
| 613 | + [0x0dd1] 0x0e31, | |
| 614 | + [0x0dd2] 0x0e32, | |
| 615 | + [0x0dd3] 0x0e33, | |
| 616 | + [0x0dd4] 0x0e34, | |
| 617 | + [0x0dd5] 0x0e35, | |
| 618 | + [0x0dd6] 0x0e36, | |
| 619 | + [0x0dd7] 0x0e37, | |
| 620 | + [0x0dd8] 0x0e38, | |
| 621 | + [0x0dd9] 0x0e39, | |
| 622 | + [0x0dda] 0x0e3a, | |
| 623 | + [0x0dde] 0x0e3e, | |
| 624 | + [0x0ddf] 0x0e3f, | |
| 625 | + [0x0de0] 0x0e40, | |
| 626 | + [0x0de1] 0x0e41, | |
| 627 | + [0x0de2] 0x0e42, | |
| 628 | + [0x0de3] 0x0e43, | |
| 629 | + [0x0de4] 0x0e44, | |
| 630 | + [0x0de5] 0x0e45, | |
| 631 | + [0x0de6] 0x0e46, | |
| 632 | + [0x0de7] 0x0e47, | |
| 633 | + [0x0de8] 0x0e48, | |
| 634 | + [0x0de9] 0x0e49, | |
| 635 | + [0x0dea] 0x0e4a, | |
| 636 | + [0x0deb] 0x0e4b, | |
| 637 | + [0x0dec] 0x0e4c, | |
| 638 | + [0x0ded] 0x0e4d, | |
| 639 | + [0x0df0] 0x0e50, | |
| 640 | + [0x0df1] 0x0e51, | |
| 641 | + [0x0df2] 0x0e52, | |
| 642 | + [0x0df3] 0x0e53, | |
| 643 | + [0x0df4] 0x0e54, | |
| 644 | + [0x0df5] 0x0e55, | |
| 645 | + [0x0df6] 0x0e56, | |
| 646 | + [0x0df7] 0x0e57, | |
| 647 | + [0x0df8] 0x0e58, | |
| 648 | + [0x0df9] 0x0e59, | |
| 649 | + [0x0ea1] 0x3131, | |
| 650 | + [0x0ea2] 0x3132, | |
| 651 | + [0x0ea3] 0x3133, | |
| 652 | + [0x0ea4] 0x3134, | |
| 653 | + [0x0ea5] 0x3135, | |
| 654 | + [0x0ea6] 0x3136, | |
| 655 | + [0x0ea7] 0x3137, | |
| 656 | + [0x0ea8] 0x3138, | |
| 657 | + [0x0ea9] 0x3139, | |
| 658 | + [0x0eaa] 0x313a, | |
| 659 | + [0x0eab] 0x313b, | |
| 660 | + [0x0eac] 0x313c, | |
| 661 | + [0x0ead] 0x313d, | |
| 662 | + [0x0eae] 0x313e, | |
| 663 | + [0x0eaf] 0x313f, | |
| 664 | + [0x0eb0] 0x3140, | |
| 665 | + [0x0eb1] 0x3141, | |
| 666 | + [0x0eb2] 0x3142, | |
| 667 | + [0x0eb3] 0x3143, | |
| 668 | + [0x0eb4] 0x3144, | |
| 669 | + [0x0eb5] 0x3145, | |
| 670 | + [0x0eb6] 0x3146, | |
| 671 | + [0x0eb7] 0x3147, | |
| 672 | + [0x0eb8] 0x3148, | |
| 673 | + [0x0eb9] 0x3149, | |
| 674 | + [0x0eba] 0x314a, | |
| 675 | + [0x0ebb] 0x314b, | |
| 676 | + [0x0ebc] 0x314c, | |
| 677 | + [0x0ebd] 0x314d, | |
| 678 | + [0x0ebe] 0x314e, | |
| 679 | + [0x0ebf] 0x314f, | |
| 680 | + [0x0ec0] 0x3150, | |
| 681 | + [0x0ec1] 0x3151, | |
| 682 | + [0x0ec2] 0x3152, | |
| 683 | + [0x0ec3] 0x3153, | |
| 684 | + [0x0ec4] 0x3154, | |
| 685 | + [0x0ec5] 0x3155, | |
| 686 | + [0x0ec6] 0x3156, | |
| 687 | + [0x0ec7] 0x3157, | |
| 688 | + [0x0ec8] 0x3158, | |
| 689 | + [0x0ec9] 0x3159, | |
| 690 | + [0x0eca] 0x315a, | |
| 691 | + [0x0ecb] 0x315b, | |
| 692 | + [0x0ecc] 0x315c, | |
| 693 | + [0x0ecd] 0x315d, | |
| 694 | + [0x0ece] 0x315e, | |
| 695 | + [0x0ecf] 0x315f, | |
| 696 | + [0x0ed0] 0x3160, | |
| 697 | + [0x0ed1] 0x3161, | |
| 698 | + [0x0ed2] 0x3162, | |
| 699 | + [0x0ed3] 0x3163, | |
| 700 | + [0x0ed4] 0x11a8, | |
| 701 | + [0x0ed5] 0x11a9, | |
| 702 | + [0x0ed6] 0x11aa, | |
| 703 | + [0x0ed7] 0x11ab, | |
| 704 | + [0x0ed8] 0x11ac, | |
| 705 | + [0x0ed9] 0x11ad, | |
| 706 | + [0x0eda] 0x11ae, | |
| 707 | + [0x0edb] 0x11af, | |
| 708 | + [0x0edc] 0x11b0, | |
| 709 | + [0x0edd] 0x11b1, | |
| 710 | + [0x0ede] 0x11b2, | |
| 711 | + [0x0edf] 0x11b3, | |
| 712 | + [0x0ee0] 0x11b4, | |
| 713 | + [0x0ee1] 0x11b5, | |
| 714 | + [0x0ee2] 0x11b6, | |
| 715 | + [0x0ee3] 0x11b7, | |
| 716 | + [0x0ee4] 0x11b8, | |
| 717 | + [0x0ee5] 0x11b9, | |
| 718 | + [0x0ee6] 0x11ba, | |
| 719 | + [0x0ee7] 0x11bb, | |
| 720 | + [0x0ee8] 0x11bc, | |
| 721 | + [0x0ee9] 0x11bd, | |
| 722 | + [0x0eea] 0x11be, | |
| 723 | + [0x0eeb] 0x11bf, | |
| 724 | + [0x0eec] 0x11c0, | |
| 725 | + [0x0eed] 0x11c1, | |
| 726 | + [0x0eee] 0x11c2, | |
| 727 | + [0x0eef] 0x316d, | |
| 728 | + [0x0ef0] 0x3171, | |
| 729 | + [0x0ef1] 0x3178, | |
| 730 | + [0x0ef2] 0x317f, | |
| 731 | + [0x0ef4] 0x3184, | |
| 732 | + [0x0ef5] 0x3186, | |
| 733 | + [0x0ef6] 0x318d, | |
| 734 | + [0x0ef7] 0x318e, | |
| 735 | + [0x0ef8] 0x11eb, | |
| 736 | + [0x0efa] 0x11f9, | |
| 737 | + [0x0eff] 0x20a9, | |
| 738 | + [0x13bc] 0x0152, | |
| 739 | + [0x13bd] 0x0153, | |
| 740 | + [0x13be] 0x0178, | |
| 741 | + [0x20a0] 0x20a0, | |
| 742 | + [0x20a1] 0x20a1, | |
| 743 | + [0x20a2] 0x20a2, | |
| 744 | + [0x20a3] 0x20a3, | |
| 745 | + [0x20a4] 0x20a4, | |
| 746 | + [0x20a5] 0x20a5, | |
| 747 | + [0x20a6] 0x20a6, | |
| 748 | + [0x20a7] 0x20a7, | |
| 749 | + [0x20a8] 0x20a8, | |
| 750 | + [0x20a9] 0x20a9, | |
| 751 | + [0x20aa] 0x20aa, | |
| 752 | + [0x20ab] 0x20ab, | |
| 753 | + [0x20ac] 0x20ac, | |
| 754 | +}; | |
| @@ -0,0 +1,16 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | +#include <draw.h> | |
| 4 | +#include <memdraw.h> | |
| 5 | +#include "xmem.h" | |
| 6 | + | |
| 7 | +int | |
| 8 | +loadmemimage(Memimage *i, Rectangle r, uchar *data, int ndata) | |
| 9 | +{ | |
| 10 | + int n; | |
| 11 | + | |
| 12 | + n = _loadmemimage(i, r, data, ndata); | |
| 13 | + if(n > 0 && i->X) | |
| 14 | + putXdata(i, r); | |
| 15 | + return n; | |
| 16 | +} | |
| @@ -0,0 +1,1094 @@ | ||
| 1 | +#include <sys/types.h> | |
| 2 | +#include <sys/stat.h> | |
| 3 | +#include <fcntl.h> | |
| 4 | +#include <termios.h> | |
| 5 | +#include <stdio.h> | |
| 6 | + | |
| 7 | +#include <X11/Xlib.h> | |
| 8 | +#include <X11/Xatom.h> | |
| 9 | +#include <X11/Xutil.h> | |
| 10 | +#include <X11/keysym.h> | |
| 11 | + | |
| 12 | +#include "keysym2ucs.h" | |
| 13 | + | |
| 14 | +/* | |
| 15 | + * alias defs for image types to overcome name conflicts | |
| 16 | + */ | |
| 17 | +#define Point IPoint | |
| 18 | +#define Rectangle IRectangle | |
| 19 | +#define Display IDisplay | |
| 20 | +#define Font IFont | |
| 21 | +#define Screen IScreen | |
| 22 | + | |
| 23 | +#include <u.h> | |
| 24 | +#include <libc.h> | |
| 25 | +#include <draw.h> | |
| 26 | +#include <memdraw.h> | |
| 27 | +#include <keyboard.h> | |
| 28 | +#include "dat.h" | |
| 29 | +#include "fns.h" | |
| 30 | +#include "screen.h" | |
| 31 | + | |
| 32 | +#undef time | |
| 33 | +#undef Point | |
| 34 | +#undef Rectangle | |
| 35 | +#undef Display | |
| 36 | +#undef Font | |
| 37 | +#undef Screen | |
| 38 | + | |
| 39 | +typedef struct ICursor ICursor; | |
| 40 | +struct ICursor | |
| 41 | +{ | |
| 42 | + int w; | |
| 43 | + int h; | |
| 44 | + int hotx; | |
| 45 | + int hoty; | |
| 46 | + char *src; | |
| 47 | + char *mask; | |
| 48 | +}; | |
| 49 | + | |
| 50 | + | |
| 51 | +#define ABS(x) ((x) < 0 ? -(x) : (x)) | |
| 52 | + | |
| 53 | +enum | |
| 54 | +{ | |
| 55 | + DblTime = 300 /* double click time in msec */ | |
| 56 | +}; | |
| 57 | + | |
| 58 | +XColor map[256]; /* Plan 9 colormap array */ | |
| 59 | +XColor map7[128]; /* Plan 9 colormap array */ | |
| 60 | +uchar map7to8[128][2]; | |
| 61 | +Colormap xcmap; /* Default shared colormap */ | |
| 62 | +int plan9tox11[256]; /* Values for mapping between */ | |
| 63 | +int x11toplan9[256]; /* X11 and Plan 9 */ | |
| 64 | +int x24bitswap = 0; /* swap endian for 24bit RGB */ | |
| 65 | +int xtblbit; | |
| 66 | +extern int mousequeue; | |
| 67 | + | |
| 68 | +/* for copy/paste, lifted from plan9ports */ | |
| 69 | +Atom clipboard; | |
| 70 | +Atom utf8string; | |
| 71 | +Atom targets; | |
| 72 | +Atom text; | |
| 73 | +Atom compoundtext; | |
| 74 | + | |
| 75 | +static XModifierKeymap *modmap; | |
| 76 | +static int keypermod; | |
| 77 | +static Drawable xdrawable; | |
| 78 | +/* static Atom wm_take_focus; */ | |
| 79 | +static void xexpose(XEvent*); | |
| 80 | +static void xmouse(XEvent*); | |
| 81 | +static void xkeyboard(XEvent*); | |
| 82 | +static void xmapping(XEvent*); | |
| 83 | +static void xdestroy(XEvent*); | |
| 84 | +static void xselect(XEvent*); | |
| 85 | +static void xproc(void*); | |
| 86 | +static Memimage* xinitscreen(void); | |
| 87 | +static void initmap(Window); | |
| 88 | +static GC creategc(Drawable); | |
| 89 | +static void graphicscmap(XColor*); | |
| 90 | + int xscreendepth; | |
| 91 | + Drawable xscreenid; | |
| 92 | + Display* xdisplay; | |
| 93 | + Display* xkmcon; | |
| 94 | + Display* xsnarfcon; | |
| 95 | + Visual *xvis; | |
| 96 | + GC xgcfill, xgccopy, xgcsimplesrc, xgczero, xgcreplsrc; | |
| 97 | + GC xgcfill0, xgccopy0, xgcsimplesrc0, xgczero0, xgcreplsrc0; | |
| 98 | + ulong xblack; | |
| 99 | + ulong xwhite; | |
| 100 | + ulong xscreenchan; | |
| 101 | + | |
| 102 | +extern Memimage* xallocmemimage(IRectangle, ulong, int); | |
| 103 | +Memimage *gscreen; | |
| 104 | +Screeninfo screen; | |
| 105 | +XImage *ximage; | |
| 106 | + | |
| 107 | +void | |
| 108 | +screeninit(void) | |
| 109 | +{ | |
| 110 | + _memmkcmap(); | |
| 111 | + | |
| 112 | + gscreen = xinitscreen(); | |
| 113 | + kproc("xscreen", xproc, nil); | |
| 114 | + | |
| 115 | + memimageinit(); | |
| 116 | + terminit(); | |
| 117 | + flushmemscreen(gscreen->r); | |
| 118 | +} | |
| 119 | + | |
| 120 | +uchar* | |
| 121 | +attachscreen(IRectangle *r, ulong *chan, int *depth, | |
| 122 | + int *width, int *softscreen, void **X) | |
| 123 | +{ | |
| 124 | + *r = gscreen->r; | |
| 125 | + *chan = gscreen->chan; | |
| 126 | + *depth = gscreen->depth; | |
| 127 | + *width = gscreen->width; | |
| 128 | + *X = gscreen->X; | |
| 129 | + *softscreen = 1; | |
| 130 | + | |
| 131 | + return gscreen->data->bdata; | |
| 132 | +} | |
| 133 | + | |
| 134 | +void | |
| 135 | +flushmemscreen(IRectangle r) | |
| 136 | +{ | |
| 137 | + if(r.min.x >= r.max.x || r.min.y >= r.max.y) | |
| 138 | + return; | |
| 139 | + XCopyArea(xdisplay, xscreenid, xdrawable, xgccopy, r.min.x, r.min.y, Dx(r), Dy(r), r.min.x, r.min.y); | |
| 140 | + XFlush(xdisplay); | |
| 141 | +} | |
| 142 | + | |
| 143 | +static int | |
| 144 | +revbyte(int b) | |
| 145 | +{ | |
| 146 | + int r; | |
| 147 | + | |
| 148 | + r = 0; | |
| 149 | + r |= (b&0x01) << 7; | |
| 150 | + r |= (b&0x02) << 5; | |
| 151 | + r |= (b&0x04) << 3; | |
| 152 | + r |= (b&0x08) << 1; | |
| 153 | + r |= (b&0x10) >> 1; | |
| 154 | + r |= (b&0x20) >> 3; | |
| 155 | + r |= (b&0x40) >> 5; | |
| 156 | + r |= (b&0x80) >> 7; | |
| 157 | + return r; | |
| 158 | +} | |
| 159 | + | |
| 160 | +void | |
| 161 | +mouseset(IPoint xy) | |
| 162 | +{ | |
| 163 | + XWarpPointer(xdisplay, None, xdrawable, 0, 0, 0, 0, xy.x, xy.y); | |
| 164 | + XFlush(xdisplay); | |
| 165 | +} | |
| 166 | + | |
| 167 | +static Cursor xcursor; | |
| 168 | + | |
| 169 | +void | |
| 170 | +setcursor(void) | |
| 171 | +{ | |
| 172 | + Cursor xc; | |
| 173 | + XColor fg, bg; | |
| 174 | + Pixmap xsrc, xmask; | |
| 175 | + int i; | |
| 176 | + uchar src[2*16], mask[2*16]; | |
| 177 | + | |
| 178 | + for(i=0; i<2*16; i++){ | |
| 179 | + src[i] = revbyte(cursor.set[i]); | |
| 180 | + mask[i] = revbyte(cursor.set[i] | cursor.clr[i]); | |
| 181 | + } | |
| 182 | + | |
| 183 | + fg = map[0]; | |
| 184 | + bg = map[255]; | |
| 185 | + xsrc = XCreateBitmapFromData(xdisplay, xdrawable, src, 16, 16); | |
| 186 | + xmask = XCreateBitmapFromData(xdisplay, xdrawable, mask, 16, 16); | |
| 187 | + xc = XCreatePixmapCursor(xdisplay, xsrc, xmask, &fg, &bg, -cursor.offset.x, -cursor.offset.y); | |
| 188 | + if(xc != 0) { | |
| 189 | + XDefineCursor(xdisplay, xdrawable, xc); | |
| 190 | + if(xcursor != 0) | |
| 191 | + XFreeCursor(xdisplay, xcursor); | |
| 192 | + xcursor = xc; | |
| 193 | + } | |
| 194 | + XFreePixmap(xdisplay, xsrc); | |
| 195 | + XFreePixmap(xdisplay, xmask); | |
| 196 | + XFlush(xdisplay); | |
| 197 | +} | |
| 198 | + | |
| 199 | +void | |
| 200 | +cursorarrow(void) | |
| 201 | +{ | |
| 202 | + if(xcursor != 0){ | |
| 203 | + XFreeCursor(xdisplay, xcursor); | |
| 204 | + xcursor = 0; | |
| 205 | + } | |
| 206 | + XUndefineCursor(xdisplay, xdrawable); | |
| 207 | + XFlush(xdisplay); | |
| 208 | +} | |
| 209 | + | |
| 210 | +static void | |
| 211 | +xproc(void *arg) | |
| 212 | +{ | |
| 213 | + ulong mask; | |
| 214 | + XEvent event; | |
| 215 | + | |
| 216 | + mask = KeyPressMask| | |
| 217 | + ButtonPressMask| | |
| 218 | + ButtonReleaseMask| | |
| 219 | + PointerMotionMask| | |
| 220 | + Button1MotionMask| | |
| 221 | + Button2MotionMask| | |
| 222 | + Button3MotionMask| | |
| 223 | + Button4MotionMask| | |
| 224 | + Button5MotionMask| | |
| 225 | + ExposureMask| | |
| 226 | + StructureNotifyMask; | |
| 227 | + | |
| 228 | + XSelectInput(xkmcon, xdrawable, mask); | |
| 229 | + for(;;) { | |
| 230 | + //XWindowEvent(xkmcon, xdrawable, mask, &event); | |
| 231 | + XNextEvent(xkmcon, &event); | |
| 232 | + xselect(&event); | |
| 233 | + xkeyboard(&event); | |
| 234 | + xmouse(&event); | |
| 235 | + xexpose(&event); | |
| 236 | + xmapping(&event); | |
| 237 | + xdestroy(&event); | |
| 238 | + } | |
| 239 | +} | |
| 240 | + | |
| 241 | +static int | |
| 242 | +shutup(Display *d, XErrorEvent *e) | |
| 243 | +{ | |
| 244 | + char buf[200]; | |
| 245 | + iprint("X error: error code=%d, request_code=%d, minor=%d\n", e->error_code, e->request_code, e->minor_code); | |
| 246 | + XGetErrorText(d, e->error_code, buf, sizeof(buf)); | |
| 247 | + iprint("%s\n", buf); | |
| 248 | + USED(d); | |
| 249 | + USED(e); | |
| 250 | + return 0; | |
| 251 | +} | |
| 252 | + | |
| 253 | +static int | |
| 254 | +panicshutup(Display *d) | |
| 255 | +{ | |
| 256 | + panic("x error"); | |
| 257 | + return -1; | |
| 258 | +} | |
| 259 | + | |
| 260 | +static Memimage* | |
| 261 | +xinitscreen(void) | |
| 262 | +{ | |
| 263 | + Memimage *gscreen; | |
| 264 | + int i, xsize, ysize, pmid; | |
| 265 | + char *argv[2]; | |
| 266 | + char *disp_val; | |
| 267 | + Window rootwin; | |
| 268 | + IRectangle r; | |
| 269 | + XWMHints hints; | |
| 270 | + Screen *screen; | |
| 271 | + XVisualInfo xvi; | |
| 272 | + int rootscreennum; | |
| 273 | + XTextProperty name; | |
| 274 | + XClassHint classhints; | |
| 275 | + XSizeHints normalhints; | |
| 276 | + XSetWindowAttributes attrs; | |
| 277 | + XPixmapFormatValues *pfmt; | |
| 278 | + int n; | |
| 279 | + Memdata *md; | |
| 280 | + | |
| 281 | + xscreenid = 0; | |
| 282 | + xdrawable = 0; | |
| 283 | + | |
| 284 | + xdisplay = XOpenDisplay(NULL); | |
| 285 | + if(xdisplay == 0){ | |
| 286 | + disp_val = getenv("DISPLAY"); | |
| 287 | + if(disp_val == 0) | |
| 288 | + disp_val = "not set"; | |
| 289 | + iprint("drawterm: open %r, DISPLAY is %s\n", disp_val); | |
| 290 | + exit(0); | |
| 291 | + } | |
| 292 | + | |
| 293 | + XSetErrorHandler(shutup); | |
| 294 | + XSetIOErrorHandler(panicshutup); | |
| 295 | + rootscreennum = DefaultScreen(xdisplay); | |
| 296 | + rootwin = DefaultRootWindow(xdisplay); | |
| 297 | + | |
| 298 | + xscreendepth = DefaultDepth(xdisplay, rootscreennum); | |
| 299 | + if(XMatchVisualInfo(xdisplay, rootscreennum, 16, TrueColor, &xvi) | |
| 300 | + || XMatchVisualInfo(xdisplay, rootscreennum, 16, DirectColor, &xvi)){ | |
| 301 | + xvis = xvi.visual; | |
| 302 | + xscreendepth = 16; | |
| 303 | + xtblbit = 1; | |
| 304 | + } | |
| 305 | + else if(XMatchVisualInfo(xdisplay, rootscreennum, 24, TrueColor, &xvi) | |
| 306 | + || XMatchVisualInfo(xdisplay, rootscreennum, 24, DirectColor, &xvi)){ | |
| 307 | + xvis = xvi.visual; | |
| 308 | + xscreendepth = 24; | |
| 309 | + xtblbit = 1; | |
| 310 | + } | |
| 311 | + else if(XMatchVisualInfo(xdisplay, rootscreennum, 8, PseudoColor, &xvi) | |
| 312 | + || XMatchVisualInfo(xdisplay, rootscreennum, 8, StaticColor, &xvi)){ | |
| 313 | + if(xscreendepth > 8) | |
| 314 | + panic("drawterm: can't deal with colormapped depth %d screens\n", xscreendepth); | |
| 315 | + xvis = xvi.visual; | |
| 316 | + xscreendepth = 8; | |
| 317 | + } | |
| 318 | + else{ | |
| 319 | + if(xscreendepth != 8) | |
| 320 | + panic("drawterm: can't deal with depth %d screens\n", xscreendepth); | |
| 321 | + xvis = DefaultVisual(xdisplay, rootscreennum); | |
| 322 | + } | |
| 323 | + | |
| 324 | + /* | |
| 325 | + * xscreendepth is only the number of significant pixel bits, | |
| 326 | + * not the total. We need to walk the display list to find | |
| 327 | + * how many actual bits are being used per pixel. | |
| 328 | + */ | |
| 329 | + xscreenchan = 0; /* not a valid channel */ | |
| 330 | + pfmt = XListPixmapFormats(xdisplay, &n); | |
| 331 | + for(i=0; i<n; i++){ | |
| 332 | + if(pfmt[i].depth == xscreendepth){ | |
| 333 | + switch(pfmt[i].bits_per_pixel){ | |
| 334 | + case 1: /* untested */ | |
| 335 | + xscreenchan = GREY1; | |
| 336 | + break; | |
| 337 | + case 2: /* untested */ | |
| 338 | + xscreenchan = GREY2; | |
| 339 | + break; | |
| 340 | + case 4: /* untested */ | |
| 341 | + xscreenchan = GREY4; | |
| 342 | + break; | |
| 343 | + case 8: | |
| 344 | + xscreenchan = CMAP8; | |
| 345 | + break; | |
| 346 | + case 16: /* uses 16 rather than 15, empirically. */ | |
| 347 | + xscreenchan = RGB16; | |
| 348 | + break; | |
| 349 | + case 24: /* untested (impossible?) */ | |
| 350 | + xscreenchan = RGB24; | |
| 351 | + break; | |
| 352 | + case 32: | |
| 353 | + xscreenchan = CHAN4(CIgnore, 8, CRed, 8, CGreen, 8, CBlue, 8); | |
| 354 | + break; | |
| 355 | + } | |
| 356 | + } | |
| 357 | + } | |
| 358 | + if(xscreenchan == 0) | |
| 359 | + panic("drawterm: unknown screen pixel format\n"); | |
| 360 | + | |
| 361 | + screen = DefaultScreenOfDisplay(xdisplay); | |
| 362 | + xcmap = DefaultColormapOfScreen(screen); | |
| 363 | + | |
| 364 | + if(xvis->class != StaticColor){ | |
| 365 | + graphicscmap(map); | |
| 366 | + initmap(rootwin); | |
| 367 | + } | |
| 368 | + | |
| 369 | + if((modmap = XGetModifierMapping(xdisplay))) | |
| 370 | + keypermod = modmap->max_keypermod; | |
| 371 | + | |
| 372 | + r.min = ZP; | |
| 373 | + r.max.x = WidthOfScreen(screen); | |
| 374 | + r.max.y = HeightOfScreen(screen); | |
| 375 | + | |
| 376 | + md = mallocz(sizeof(Memdata), 1); | |
| 377 | + | |
| 378 | + xsize = Dx(r)*3/4; | |
| 379 | + ysize = Dy(r)*3/4; | |
| 380 | + | |
| 381 | + attrs.colormap = xcmap; | |
| 382 | + attrs.background_pixel = 0; | |
| 383 | + attrs.border_pixel = 0; | |
| 384 | + /* attrs.override_redirect = 1;*/ /* WM leave me alone! |CWOverrideRedirect */ | |
| 385 | + xdrawable = XCreateWindow(xdisplay, rootwin, 0, 0, xsize, ysize, 0, | |
| 386 | + xscreendepth, InputOutput, xvis, CWBackPixel|CWBorderPixel|CWColormap, &attrs); | |
| 387 | + | |
| 388 | + /* | |
| 389 | + * set up property as required by ICCCM | |
| 390 | + */ | |
| 391 | + name.value = (uchar*)"drawterm"; | |
| 392 | + name.encoding = XA_STRING; | |
| 393 | + name.format = 8; | |
| 394 | + name.nitems = strlen(name.value); | |
| 395 | + normalhints.flags = USSize|PMaxSize; | |
| 396 | + normalhints.max_width = Dx(r); | |
| 397 | + normalhints.max_height = Dy(r); | |
| 398 | + normalhints.width = xsize; | |
| 399 | + normalhints.height = ysize; | |
| 400 | + hints.flags = InputHint|StateHint; | |
| 401 | + hints.input = 1; | |
| 402 | + hints.initial_state = NormalState; | |
| 403 | + classhints.res_name = "drawterm"; | |
| 404 | + classhints.res_class = "Drawterm"; | |
| 405 | + argv[0] = "drawterm"; | |
| 406 | + argv[1] = nil; | |
| 407 | + XSetWMProperties(xdisplay, xdrawable, | |
| 408 | + &name, /* XA_WM_NAME property for ICCCM */ | |
| 409 | + &name, /* XA_WM_ICON_NAME */ | |
| 410 | + argv, /* XA_WM_COMMAND */ | |
| 411 | + 1, /* argc */ | |
| 412 | + &normalhints, /* XA_WM_NORMAL_HINTS */ | |
| 413 | + &hints, /* XA_WM_HINTS */ | |
| 414 | + &classhints); /* XA_WM_CLASS */ | |
| 415 | + XFlush(xdisplay); | |
| 416 | + | |
| 417 | + /* | |
| 418 | + * put the window on the screen | |
| 419 | + */ | |
| 420 | + XMapWindow(xdisplay, xdrawable); | |
| 421 | + XFlush(xdisplay); | |
| 422 | + | |
| 423 | + xscreenid = XCreatePixmap(xdisplay, xdrawable, Dx(r), Dy(r), xscreendepth); | |
| 424 | + gscreen = xallocmemimage(r, xscreenchan, xscreenid); | |
| 425 | + | |
| 426 | + xgcfill = creategc(xscreenid); | |
| 427 | + XSetFillStyle(xdisplay, xgcfill, FillSolid); | |
| 428 | + xgccopy = creategc(xscreenid); | |
| 429 | + xgcsimplesrc = creategc(xscreenid); | |
| 430 | + XSetFillStyle(xdisplay, xgcsimplesrc, FillStippled); | |
| 431 | + xgczero = creategc(xscreenid); | |
| 432 | + xgcreplsrc = creategc(xscreenid); | |
| 433 | + XSetFillStyle(xdisplay, xgcreplsrc, FillTiled); | |
| 434 | + | |
| 435 | + pmid = XCreatePixmap(xdisplay, xdrawable, 1, 1, 1); | |
| 436 | + xgcfill0 = creategc(pmid); | |
| 437 | + XSetForeground(xdisplay, xgcfill0, 0); | |
| 438 | + XSetFillStyle(xdisplay, xgcfill0, FillSolid); | |
| 439 | + xgccopy0 = creategc(pmid); | |
| 440 | + xgcsimplesrc0 = creategc(pmid); | |
| 441 | + XSetFillStyle(xdisplay, xgcsimplesrc0, FillStippled); | |
| 442 | + xgczero0 = creategc(pmid); | |
| 443 | + xgcreplsrc0 = creategc(pmid); | |
| 444 | + XSetFillStyle(xdisplay, xgcreplsrc0, FillTiled); | |
| 445 | + XFreePixmap(xdisplay, pmid); | |
| 446 | + | |
| 447 | + XSetForeground(xdisplay, xgccopy, plan9tox11[0]); | |
| 448 | + XFillRectangle(xdisplay, xscreenid, xgccopy, 0, 0, xsize, ysize); | |
| 449 | + | |
| 450 | + xkmcon = XOpenDisplay(NULL); | |
| 451 | + if(xkmcon == 0){ | |
| 452 | + disp_val = getenv("DISPLAY"); | |
| 453 | + if(disp_val == 0) | |
| 454 | + disp_val = "not set"; | |
| 455 | + iprint("drawterm: open %r, DISPLAY is %s\n", disp_val); | |
| 456 | + exit(0); | |
| 457 | + } | |
| 458 | + xsnarfcon = XOpenDisplay(NULL); | |
| 459 | + if(xsnarfcon == 0){ | |
| 460 | + disp_val = getenv("DISPLAY"); | |
| 461 | + if(disp_val == 0) | |
| 462 | + disp_val = "not set"; | |
| 463 | + iprint("drawterm: open %r, DISPLAY is %s\n", disp_val); | |
| 464 | + exit(0); | |
| 465 | + } | |
| 466 | + | |
| 467 | + clipboard = XInternAtom(xkmcon, "CLIPBOARD", False); | |
| 468 | + utf8string = XInternAtom(xkmcon, "UTF8_STRING", False); | |
| 469 | + targets = XInternAtom(xkmcon, "TARGETS", False); | |
| 470 | + text = XInternAtom(xkmcon, "TEXT", False); | |
| 471 | + compoundtext = XInternAtom(xkmcon, "COMPOUND_TEXT", False); | |
| 472 | + | |
| 473 | + xblack = screen->black_pixel; | |
| 474 | + xwhite = screen->white_pixel; | |
| 475 | + return gscreen; | |
| 476 | +} | |
| 477 | + | |
| 478 | +static void | |
| 479 | +graphicscmap(XColor *map) | |
| 480 | +{ | |
| 481 | + int r, g, b, cr, cg, cb, v, num, den, idx, v7, idx7; | |
| 482 | + | |
| 483 | + for(r=0; r!=4; r++) { | |
| 484 | + for(g = 0; g != 4; g++) { | |
| 485 | + for(b = 0; b!=4; b++) { | |
| 486 | + for(v = 0; v!=4; v++) { | |
| 487 | + den=r; | |
| 488 | + if(g > den) | |
| 489 | + den=g; | |
| 490 | + if(b > den) | |
| 491 | + den=b; | |
| 492 | + /* divide check -- pick grey shades */ | |
| 493 | + if(den==0) | |
| 494 | + cr=cg=cb=v*17; | |
| 495 | + else { | |
| 496 | + num=17*(4*den+v); | |
| 497 | + cr=r*num/den; | |
| 498 | + cg=g*num/den; | |
| 499 | + cb=b*num/den; | |
| 500 | + } | |
| 501 | + idx = r*64 + v*16 + ((g*4 + b + v - r) & 15); | |
| 502 | + map[idx].red = cr*0x0101; | |
| 503 | + map[idx].green = cg*0x0101; | |
| 504 | + map[idx].blue = cb*0x0101; | |
| 505 | + map[idx].pixel = idx; | |
| 506 | + map[idx].flags = DoRed|DoGreen|DoBlue; | |
| 507 | + | |
| 508 | + v7 = v >> 1; | |
| 509 | + idx7 = r*32 + v7*16 + g*4 + b; | |
| 510 | + if((v & 1) == v7){ | |
| 511 | + map7to8[idx7][0] = idx; | |
| 512 | + if(den == 0) { /* divide check -- pick grey shades */ | |
| 513 | + cr = ((255.0/7.0)*v7)+0.5; | |
| 514 | + cg = cr; | |
| 515 | + cb = cr; | |
| 516 | + } | |
| 517 | + else { | |
| 518 | + num=17*15*(4*den+v7*2)/14; | |
| 519 | + cr=r*num/den; | |
| 520 | + cg=g*num/den; | |
| 521 | + cb=b*num/den; | |
| 522 | + } | |
| 523 | + map7[idx7].red = cr*0x0101; | |
| 524 | + map7[idx7].green = cg*0x0101; | |
| 525 | + map7[idx7].blue = cb*0x0101; | |
| 526 | + map7[idx7].pixel = idx7; | |
| 527 | + map7[idx7].flags = DoRed|DoGreen|DoBlue; | |
| 528 | + } | |
| 529 | + else | |
| 530 | + map7to8[idx7][1] = idx; | |
| 531 | + } | |
| 532 | + } | |
| 533 | + } | |
| 534 | + } | |
| 535 | +} | |
| 536 | + | |
| 537 | +/* | |
| 538 | + * Initialize and install the drawterm colormap as a private colormap for this | |
| 539 | + * application. Drawterm gets the best colors here when it has the cursor focus. | |
| 540 | + */ | |
| 541 | +static void | |
| 542 | +initmap(Window w) | |
| 543 | +{ | |
| 544 | + XColor c; | |
| 545 | + int i; | |
| 546 | + ulong p, pp; | |
| 547 | + char buf[30]; | |
| 548 | + | |
| 549 | + if(xscreendepth <= 1) | |
| 550 | + return; | |
| 551 | + | |
| 552 | + if(xscreendepth >= 24) { | |
| 553 | + /* The pixel value returned from XGetPixel needs to | |
| 554 | + * be converted to RGB so we can call rgb2cmap() | |
| 555 | + * to translate between 24 bit X and our color. Unfortunately, | |
| 556 | + * the return value appears to be display server endian | |
| 557 | + * dependant. Therefore, we run some heuristics to later | |
| 558 | + * determine how to mask the int value correctly. | |
| 559 | + * Yeah, I know we can look at xvis->byte_order but | |
| 560 | + * some displays say MSB even though they run on LSB. | |
| 561 | + * Besides, this is more anal. | |
| 562 | + */ | |
| 563 | + | |
| 564 | + c = map[19]; | |
| 565 | + /* find out index into colormap for our RGB */ | |
| 566 | + if(!XAllocColor(xdisplay, xcmap, &c)) | |
| 567 | + panic("drawterm: screen-x11 can't alloc color"); | |
| 568 | + | |
| 569 | + p = c.pixel; | |
| 570 | + pp = rgb2cmap((p>>16)&0xff,(p>>8)&0xff,p&0xff); | |
| 571 | + if(pp!=map[19].pixel) { | |
| 572 | + /* check if endian is other way */ | |
| 573 | + pp = rgb2cmap(p&0xff,(p>>8)&0xff,(p>>16)&0xff); | |
| 574 | + if(pp!=map[19].pixel) | |
| 575 | + panic("cannot detect x server byte order"); | |
| 576 | + switch(xscreenchan){ | |
| 577 | + case RGB24: | |
| 578 | + xscreenchan = BGR24; | |
| 579 | + break; | |
| 580 | + case XRGB32: | |
| 581 | + xscreenchan = XBGR32; | |
| 582 | + break; | |
| 583 | + default: | |
| 584 | + panic("don't know how to byteswap channel %s", | |
| 585 | + chantostr(buf, xscreenchan)); | |
| 586 | + break; | |
| 587 | + } | |
| 588 | + } | |
| 589 | + } else if(xvis->class == TrueColor || xvis->class == DirectColor) { | |
| 590 | + } else if(xvis->class == PseudoColor) { | |
| 591 | + if(xtblbit == 0){ | |
| 592 | + xcmap = XCreateColormap(xdisplay, w, xvis, AllocAll); | |
| 593 | + XStoreColors(xdisplay, xcmap, map, 256); | |
| 594 | + for(i = 0; i < 256; i++) { | |
| 595 | + plan9tox11[i] = i; | |
| 596 | + x11toplan9[i] = i; | |
| 597 | + } | |
| 598 | + } | |
| 599 | + else { | |
| 600 | + for(i = 0; i < 128; i++) { | |
| 601 | + c = map7[i]; | |
| 602 | + if(!XAllocColor(xdisplay, xcmap, &c)) { | |
| 603 | + iprint("drawterm: can't alloc colors in default map, don't use -7\n"); | |
| 604 | + exit(0); | |
| 605 | + } | |
| 606 | + plan9tox11[map7to8[i][0]] = c.pixel; | |
| 607 | + plan9tox11[map7to8[i][1]] = c.pixel; | |
| 608 | + x11toplan9[c.pixel] = map7to8[i][0]; | |
| 609 | + } | |
| 610 | + } | |
| 611 | + } | |
| 612 | + else | |
| 613 | + panic("drawterm: unsupported visual class %d\n", xvis->class); | |
| 614 | +} | |
| 615 | + | |
| 616 | +static void | |
| 617 | +xdestroy(XEvent *e) | |
| 618 | +{ | |
| 619 | + XDestroyWindowEvent *xe; | |
| 620 | + if(e->type != DestroyNotify) | |
| 621 | + return; | |
| 622 | + xe = (XDestroyWindowEvent*)e; | |
| 623 | + if(xe->window == xdrawable) | |
| 624 | + exit(0); | |
| 625 | +} | |
| 626 | + | |
| 627 | +static void | |
| 628 | +xselection(XEvent *e) | |
| 629 | +{ | |
| 630 | + XSelectionRequestEvent *xre; | |
| 631 | + XSelectionEvent *xe; | |
| 632 | +} | |
| 633 | + | |
| 634 | +static void | |
| 635 | +xmapping(XEvent *e) | |
| 636 | +{ | |
| 637 | + XMappingEvent *xe; | |
| 638 | + | |
| 639 | + if(e->type != MappingNotify) | |
| 640 | + return; | |
| 641 | + xe = (XMappingEvent*)e; | |
| 642 | + if(modmap) | |
| 643 | + XFreeModifiermap(modmap); | |
| 644 | + modmap = XGetModifierMapping(xe->display); | |
| 645 | + if(modmap) | |
| 646 | + keypermod = modmap->max_keypermod; | |
| 647 | +} | |
| 648 | + | |
| 649 | + | |
| 650 | +/* | |
| 651 | + * Disable generation of GraphicsExpose/NoExpose events in the GC. | |
| 652 | + */ | |
| 653 | +static GC | |
| 654 | +creategc(Drawable d) | |
| 655 | +{ | |
| 656 | + XGCValues gcv; | |
| 657 | + | |
| 658 | + gcv.function = GXcopy; | |
| 659 | + gcv.graphics_exposures = False; | |
| 660 | + return XCreateGC(xdisplay, d, GCFunction|GCGraphicsExposures, &gcv); | |
| 661 | +} | |
| 662 | + | |
| 663 | +static void | |
| 664 | +xexpose(XEvent *e) | |
| 665 | +{ | |
| 666 | + IRectangle r; | |
| 667 | + XExposeEvent *xe; | |
| 668 | + | |
| 669 | + if(e->type != Expose) | |
| 670 | + return; | |
| 671 | + xe = (XExposeEvent*)e; | |
| 672 | + r.min.x = xe->x; | |
| 673 | + r.min.y = xe->y; | |
| 674 | + r.max.x = xe->x + xe->width; | |
| 675 | + r.max.y = xe->y + xe->height; | |
| 676 | + drawflushr(r); | |
| 677 | +} | |
| 678 | + | |
| 679 | +static void | |
| 680 | +xkeyboard(XEvent *e) | |
| 681 | +{ | |
| 682 | + KeySym k; | |
| 683 | + unsigned int md; | |
| 684 | + | |
| 685 | + /* | |
| 686 | + * I tried using XtGetActionKeysym, but it didn't seem to | |
| 687 | + * do case conversion properly | |
| 688 | + * (at least, with Xterminal servers and R4 intrinsics) | |
| 689 | + */ | |
| 690 | + if(e->xany.type != KeyPress) | |
| 691 | + return; | |
| 692 | + | |
| 693 | + | |
| 694 | + XLookupString(e,NULL,0,&k,NULL); | |
| 695 | + | |
| 696 | + if(k == XK_Multi_key || k == NoSymbol) | |
| 697 | + return; | |
| 698 | + if(k&0xFF00){ | |
| 699 | + switch(k){ | |
| 700 | + case XK_BackSpace: | |
| 701 | + case XK_Tab: | |
| 702 | + case XK_Escape: | |
| 703 | + case XK_Delete: | |
| 704 | + case XK_KP_0: | |
| 705 | + case XK_KP_1: | |
| 706 | + case XK_KP_2: | |
| 707 | + case XK_KP_3: | |
| 708 | + case XK_KP_4: | |
| 709 | + case XK_KP_5: | |
| 710 | + case XK_KP_6: | |
| 711 | + case XK_KP_7: | |
| 712 | + case XK_KP_8: | |
| 713 | + case XK_KP_9: | |
| 714 | + case XK_KP_Divide: | |
| 715 | + case XK_KP_Multiply: | |
| 716 | + case XK_KP_Subtract: | |
| 717 | + case XK_KP_Add: | |
| 718 | + case XK_KP_Decimal: | |
| 719 | + k &= 0x7F; | |
| 720 | + break; | |
| 721 | + case XK_Linefeed: | |
| 722 | + k = '\r'; | |
| 723 | + break; | |
| 724 | + case XK_KP_Space: | |
| 725 | + k = ' '; | |
| 726 | + break; | |
| 727 | + case XK_Home: | |
| 728 | + case XK_KP_Home: | |
| 729 | + k = Khome; | |
| 730 | + break; | |
| 731 | + case XK_Left: | |
| 732 | + case XK_KP_Left: | |
| 733 | + k = Kleft; | |
| 734 | + break; | |
| 735 | + case XK_Up: | |
| 736 | + case XK_KP_Up: | |
| 737 | + k = Kup; | |
| 738 | + break; | |
| 739 | + case XK_Down: | |
| 740 | + case XK_KP_Down: | |
| 741 | + k = Kdown; | |
| 742 | + break; | |
| 743 | + case XK_Right: | |
| 744 | + case XK_KP_Right: | |
| 745 | + k = Kright; | |
| 746 | + break; | |
| 747 | + case XK_Page_Down: | |
| 748 | + case XK_KP_Page_Down: | |
| 749 | + k = Kpgdown; | |
| 750 | + break; | |
| 751 | + case XK_End: | |
| 752 | + case XK_KP_End: | |
| 753 | + k = Kend; | |
| 754 | + break; | |
| 755 | + case XK_Page_Up: | |
| 756 | + case XK_KP_Page_Up: | |
| 757 | + k = Kpgup; | |
| 758 | + break; | |
| 759 | + case XK_Insert: | |
| 760 | + case XK_KP_Insert: | |
| 761 | + k = Kins; | |
| 762 | + break; | |
| 763 | + case XK_KP_Enter: | |
| 764 | + case XK_Return: | |
| 765 | + k = '\n'; | |
| 766 | + break; | |
| 767 | + case XK_Alt_L: | |
| 768 | + case XK_Alt_R: | |
| 769 | + k = Kalt; | |
| 770 | + break; | |
| 771 | + case XK_Shift_L: | |
| 772 | + case XK_Shift_R: | |
| 773 | + case XK_Control_L: | |
| 774 | + case XK_Control_R: | |
| 775 | + case XK_Caps_Lock: | |
| 776 | + case XK_Shift_Lock: | |
| 777 | + | |
| 778 | + case XK_Meta_L: | |
| 779 | + case XK_Meta_R: | |
| 780 | + case XK_Super_L: | |
| 781 | + case XK_Super_R: | |
| 782 | + case XK_Hyper_L: | |
| 783 | + case XK_Hyper_R: | |
| 784 | + return; | |
| 785 | + default: /* not ISO-1 or tty control */ | |
| 786 | + if(k>0xff) { | |
| 787 | + k = keysym2ucs(k); /* supplied by X */ | |
| 788 | + if(k == -1) return; | |
| 789 | + } | |
| 790 | + } | |
| 791 | + } | |
| 792 | + | |
| 793 | + /* Compensate for servers that call a minus a hyphen */ | |
| 794 | + if(k == XK_hyphen) | |
| 795 | + k = XK_minus; | |
| 796 | + /* Do control mapping ourselves if translator doesn't */ | |
| 797 | + if(e->xkey.state&ControlMask) | |
| 798 | + k &= 0x9f; | |
| 799 | + if(k == NoSymbol) { | |
| 800 | + return; | |
| 801 | + } | |
| 802 | + | |
| 803 | + kbdputc(kbdq, k); | |
| 804 | +} | |
| 805 | + | |
| 806 | +static void | |
| 807 | +xmouse(XEvent *e) | |
| 808 | +{ | |
| 809 | + Mousestate ms; | |
| 810 | + int i, s; | |
| 811 | + XButtonEvent *be; | |
| 812 | + XMotionEvent *me; | |
| 813 | + | |
| 814 | + switch(e->type){ | |
| 815 | + case ButtonPress: | |
| 816 | + be = (XButtonEvent *)e; | |
| 817 | + ms.xy.x = be->x; | |
| 818 | + ms.xy.y = be->y; | |
| 819 | + s = be->state; | |
| 820 | + ms.msec = be->time; | |
| 821 | + switch(be->button){ | |
| 822 | + case 1: | |
| 823 | + s |= Button1Mask; | |
| 824 | + break; | |
| 825 | + case 2: | |
| 826 | + s |= Button2Mask; | |
| 827 | + break; | |
| 828 | + case 3: | |
| 829 | + s |= Button3Mask; | |
| 830 | + break; | |
| 831 | + case 4: | |
| 832 | + s |= Button4Mask; | |
| 833 | + break; | |
| 834 | + case 5: | |
| 835 | + s |= Button5Mask; | |
| 836 | + break; | |
| 837 | + } | |
| 838 | + break; | |
| 839 | + case ButtonRelease: | |
| 840 | + be = (XButtonEvent *)e; | |
| 841 | + ms.xy.x = be->x; | |
| 842 | + ms.xy.y = be->y; | |
| 843 | + ms.msec = be->time; | |
| 844 | + s = be->state; | |
| 845 | + switch(be->button){ | |
| 846 | + case 1: | |
| 847 | + s &= ~Button1Mask; | |
| 848 | + break; | |
| 849 | + case 2: | |
| 850 | + s &= ~Button2Mask; | |
| 851 | + break; | |
| 852 | + case 3: | |
| 853 | + s &= ~Button3Mask; | |
| 854 | + break; | |
| 855 | + case 4: | |
| 856 | + s &= ~Button4Mask; | |
| 857 | + break; | |
| 858 | + case 5: | |
| 859 | + s &= ~Button5Mask; | |
| 860 | + break; | |
| 861 | + } | |
| 862 | + break; | |
| 863 | + case MotionNotify: | |
| 864 | + me = (XMotionEvent *)e; | |
| 865 | + s = me->state; | |
| 866 | + ms.xy.x = me->x; | |
| 867 | + ms.xy.y = me->y; | |
| 868 | + ms.msec = me->time; | |
| 869 | + break; | |
| 870 | + default: | |
| 871 | + return; | |
| 872 | + } | |
| 873 | + | |
| 874 | + ms.buttons = 0; | |
| 875 | + if(s & Button1Mask) | |
| 876 | + ms.buttons |= 1; | |
| 877 | + if(s & Button2Mask) | |
| 878 | + ms.buttons |= 2; | |
| 879 | + if(s & Button3Mask) | |
| 880 | + ms.buttons |= 4; | |
| 881 | + if(s & Button4Mask) | |
| 882 | + ms.buttons |= 8; | |
| 883 | + if(s & Button5Mask) | |
| 884 | + ms.buttons |= 16; | |
| 885 | + | |
| 886 | + lock(&mouse.lk); | |
| 887 | + i = mouse.wi; | |
| 888 | + if(mousequeue) { | |
| 889 | + if(i == mouse.ri || mouse.lastb != ms.buttons || mouse.trans) { | |
| 890 | + mouse.wi = (i+1)%Mousequeue; | |
| 891 | + if(mouse.wi == mouse.ri) | |
| 892 | + mouse.ri = (mouse.ri+1)%Mousequeue; | |
| 893 | + mouse.trans = mouse.lastb != ms.buttons; | |
| 894 | + } else { | |
| 895 | + i = (i-1+Mousequeue)%Mousequeue; | |
| 896 | + } | |
| 897 | + } else { | |
| 898 | + mouse.wi = (i+1)%Mousequeue; | |
| 899 | + mouse.ri = i; | |
| 900 | + } | |
| 901 | + mouse.queue[i] = ms; | |
| 902 | + mouse.lastb = ms.buttons; | |
| 903 | + unlock(&mouse.lk); | |
| 904 | + wakeup(&mouse.r); | |
| 905 | +} | |
| 906 | + | |
| 907 | +void | |
| 908 | +getcolor(ulong i, ulong *r, ulong *g, ulong *b) | |
| 909 | +{ | |
| 910 | + ulong v; | |
| 911 | + | |
| 912 | + v = cmap2rgb(i); | |
| 913 | + *r = (v>>16)&0xFF; | |
| 914 | + *g = (v>>8)&0xFF; | |
| 915 | + *b = v&0xFF; | |
| 916 | +} | |
| 917 | + | |
| 918 | +void | |
| 919 | +setcolor(ulong i, ulong r, ulong g, ulong b) | |
| 920 | +{ | |
| 921 | + /* no-op */ | |
| 922 | +} | |
| 923 | + | |
| 924 | +typedef struct Clip Clip; | |
| 925 | +struct Clip | |
| 926 | +{ | |
| 927 | + char buf[SnarfSize]; | |
| 928 | + ulong n; | |
| 929 | + int want, have; | |
| 930 | + QLock lk; | |
| 931 | + Rendez vous; | |
| 932 | +}; | |
| 933 | + | |
| 934 | +Clip clip; | |
| 935 | + | |
| 936 | +enum { | |
| 937 | + Chunk = 2048 | |
| 938 | +}; | |
| 939 | + | |
| 940 | +static void | |
| 941 | +xselect(XEvent *e) | |
| 942 | +{ | |
| 943 | + XSelectionRequestEvent *q; | |
| 944 | + XEvent r; | |
| 945 | + Atom a[4]; | |
| 946 | + char *name; | |
| 947 | + | |
| 948 | + | |
| 949 | + if(e->type != SelectionRequest) | |
| 950 | + return; | |
| 951 | + | |
| 952 | + /* | |
| 953 | + * The lock is around the whole routine because we use the | |
| 954 | + * lock to make sure two people aren't sending on xkmcon | |
| 955 | + * at once. | |
| 956 | + */ | |
| 957 | + q = (XSelectionRequestEvent*)e; | |
| 958 | + | |
| 959 | + r.xselection.property = q->property; | |
| 960 | + if(q->target == targets) { | |
| 961 | + a[0] = XA_STRING; | |
| 962 | + a[1] = utf8string; | |
| 963 | + a[2] = text; | |
| 964 | + a[3] = compoundtext; | |
| 965 | + | |
| 966 | + XChangeProperty(xkmcon, q->requestor, q->property, q->target, | |
| 967 | + 8, PropModeReplace, (uchar*)a, sizeof a); | |
| 968 | + }else if(q->target == XA_STRING || q->target == utf8string || q->target == text || q->target == compoundtext){ | |
| 969 | + qlock(&clip.lk); | |
| 970 | + XChangeProperty(xkmcon, q->requestor, q->property, q->target, 8, | |
| 971 | + PropModeReplace, (uchar*)clip.buf, strlen(clip.buf)); | |
| 972 | + qunlock(&clip.lk); | |
| 973 | + }else { | |
| 974 | + name = XGetAtomName(xkmcon, q->target); | |
| 975 | + if(strcmp(name, "TIMESTAMP") != 0) | |
| 976 | + fprint(2, "%s: cannot handle selection request for '%s' (%d)\n", argv0, name, (int)q->target); | |
| 977 | + r.xselection.property = None; | |
| 978 | + } | |
| 979 | + | |
| 980 | + r.xselection.type = SelectionNotify; | |
| 981 | + r.xselection.display = q->display; | |
| 982 | + r.xselection.requestor = q->requestor; | |
| 983 | + r.xselection.selection = q->selection; | |
| 984 | + r.xselection.target = q->target; | |
| 985 | + r.xselection.time = q->time; | |
| 986 | + XSendEvent(xkmcon, q->requestor, False, 0, &r); | |
| 987 | + XFlush(xkmcon); | |
| 988 | +} | |
| 989 | + | |
| 990 | +int | |
| 991 | +haveclip(void *a) | |
| 992 | +{ | |
| 993 | + return clip.want == clip.have; | |
| 994 | +} | |
| 995 | + | |
| 996 | +#undef long /* sic */ | |
| 997 | +char* | |
| 998 | +clipread(void) | |
| 999 | +{ | |
| 1000 | + Window w; | |
| 1001 | + XEvent e; | |
| 1002 | + Atom type; | |
| 1003 | + unsigned long len, lleft, left, dummy; | |
| 1004 | + int i, fmt, res; | |
| 1005 | + uchar *data; | |
| 1006 | + | |
| 1007 | + qlock(&clip.lk); | |
| 1008 | + w = XGetSelectionOwner(xsnarfcon, XA_PRIMARY); | |
| 1009 | + if(w == xdrawable) | |
| 1010 | + data = (uchar*)strdup(clip.buf); | |
| 1011 | + else if(w == None) | |
| 1012 | + data = nil; | |
| 1013 | + else { | |
| 1014 | + /* | |
| 1015 | + * we're supposed to get a notification, but we seem not to, | |
| 1016 | + * so let's just watch and see when the buffer stabilizes. | |
| 1017 | + * if you know how to fix this, mail rsc@plan9.bell-labs.com. | |
| 1018 | + */ | |
| 1019 | + XChangeProperty(xsnarfcon, xdrawable, XA_PRIMARY, XA_STRING, 8, PropModeReplace, | |
| 1020 | + (uchar*)"", 0); | |
| 1021 | + XConvertSelection(xsnarfcon, XA_PRIMARY, XA_STRING, None, xdrawable, CurrentTime); | |
| 1022 | + XFlush(xsnarfcon); | |
| 1023 | + for(i=0; i<30; i++){ | |
| 1024 | + osmsleep(100); | |
| 1025 | + XGetWindowProperty(xsnarfcon, xdrawable, XA_STRING, 0, 0, 0, AnyPropertyType, | |
| 1026 | + &type, &fmt, &len, &left, &data); | |
| 1027 | + if(lleft == left && left > 0) | |
| 1028 | + break; | |
| 1029 | + lleft = left; | |
| 1030 | + } | |
| 1031 | + if(left > 0){ | |
| 1032 | + res = XGetWindowProperty(xsnarfcon, xdrawable, XA_STRING, 0, left, 0, | |
| 1033 | + AnyPropertyType, &type, &fmt, &len, &dummy, &data); | |
| 1034 | + data = (uchar*)strdup(data); | |
| 1035 | + }else | |
| 1036 | + data = nil; | |
| 1037 | + } | |
| 1038 | + qunlock(&clip.lk); | |
| 1039 | + return (char*)data; | |
| 1040 | +} | |
| 1041 | + | |
| 1042 | +int | |
| 1043 | +clipwrite(char *buf) | |
| 1044 | +{ | |
| 1045 | + int n; | |
| 1046 | + | |
| 1047 | + n = strlen(buf); | |
| 1048 | + qlock(&clip.lk); | |
| 1049 | + if(n >= SnarfSize) | |
| 1050 | + n = SnarfSize - 1; | |
| 1051 | + memmove(clip.buf, buf, n); | |
| 1052 | + clip.buf[n] = 0; | |
| 1053 | + clip.n = n; | |
| 1054 | + /* | |
| 1055 | + * xkmcon so that we get the event in the select loop. | |
| 1056 | + * It seems to be okay to send a message and read an event | |
| 1057 | + * from a Display* at the same time. Let's hope so. | |
| 1058 | + */ | |
| 1059 | + XSetSelectionOwner(xkmcon, XA_PRIMARY, xdrawable, CurrentTime); | |
| 1060 | + XFlush(xkmcon); | |
| 1061 | + qunlock(&clip.lk); | |
| 1062 | + return n; | |
| 1063 | +} | |
| 1064 | +#define long int /* sic */ | |
| 1065 | + | |
| 1066 | +int | |
| 1067 | +atlocalconsole(void) | |
| 1068 | +{ | |
| 1069 | + char *p, *q; | |
| 1070 | + char buf[128]; | |
| 1071 | + | |
| 1072 | + p = getenv("DISPLAY"); | |
| 1073 | + if(p == nil) | |
| 1074 | + return 0; | |
| 1075 | + | |
| 1076 | + /* extract host part */ | |
| 1077 | + q = strchr(p, ':'); | |
| 1078 | + if(q == nil) | |
| 1079 | + return 0; | |
| 1080 | + *q = 0; | |
| 1081 | + | |
| 1082 | + if(strcmp(p, "") == 0) | |
| 1083 | + return 1; | |
| 1084 | + | |
| 1085 | + /* try to match against system name (i.e. for ssh) */ | |
| 1086 | + if(gethostname(buf, sizeof buf) == 0){ | |
| 1087 | + if(strcmp(p, buf) == 0) | |
| 1088 | + return 1; | |
| 1089 | + if(strncmp(p, buf, strlen(p)) == 0 && buf[strlen(p)]=='.') | |
| 1090 | + return 1; | |
| 1091 | + } | |
| 1092 | + | |
| 1093 | + return 0; | |
| 1094 | +} | |
| @@ -0,0 +1,60 @@ | ||
| 1 | +#define Font XXFont | |
| 2 | +#define Screen XXScreen | |
| 3 | +#define Display XXDisplay | |
| 4 | + | |
| 5 | +#include <X11/Xlib.h> | |
| 6 | +/* #include <X11/Xlibint.h> */ | |
| 7 | +#include <X11/Xatom.h> | |
| 8 | +#include <X11/Xutil.h> | |
| 9 | +#include <X11/IntrinsicP.h> | |
| 10 | +#include <X11/StringDefs.h> | |
| 11 | + | |
| 12 | +#undef Font | |
| 13 | +#undef Screen | |
| 14 | +#undef Display | |
| 15 | + | |
| 16 | +/* | |
| 17 | + * Structure pointed to by X field of Memimage | |
| 18 | + */ | |
| 19 | +typedef struct Xmem Xmem; | |
| 20 | + | |
| 21 | +enum | |
| 22 | +{ | |
| 23 | + PMundef = ~0 /* undefined pixmap id */ | |
| 24 | +}; | |
| 25 | + | |
| 26 | + | |
| 27 | +struct Xmem | |
| 28 | +{ | |
| 29 | + int pmid; /* pixmap id for screen ldepth instance */ | |
| 30 | + XImage *xi; /* local image if we currenty have the data */ | |
| 31 | + int dirty; | |
| 32 | + Rectangle dirtyr; | |
| 33 | + Rectangle r; | |
| 34 | + ulong pc; /* who wrote into xi */ | |
| 35 | +}; | |
| 36 | + | |
| 37 | +extern int xtblbit; | |
| 38 | +extern int x24bitswap; | |
| 39 | +extern int plan9tox11[]; | |
| 40 | +extern int x11toplan9[]; | |
| 41 | +extern int xscreendepth; | |
| 42 | +extern XXDisplay *xdisplay; | |
| 43 | +extern Drawable xscreenid; | |
| 44 | +extern Visual *xvis; | |
| 45 | +extern GC xgcfill, xgcfill0; | |
| 46 | +extern int xgcfillcolor, xgcfillcolor0; | |
| 47 | +extern GC xgccopy, xgccopy0; | |
| 48 | +extern GC xgczero, xgczero0; | |
| 49 | +extern int xgczeropm, xgczeropm0; | |
| 50 | +extern GC xgcsimplesrc, xgcsimplesrc0; | |
| 51 | +extern int xgcsimplecolor, xgcsimplecolor0, xgcsimplepm, xgcsimplepm0; | |
| 52 | +extern GC xgcreplsrc, xgcreplsrc0; | |
| 53 | +extern int xgcreplsrcpm, xgcreplsrcpm0, xgcreplsrctile, xgcreplsrctile0; | |
| 54 | +extern XImage* allocXdata(Memimage*, Rectangle); | |
| 55 | +extern void putXdata(Memimage*, Rectangle); | |
| 56 | +extern XImage* getXdata(Memimage*, Rectangle); | |
| 57 | +extern void freeXdata(Memimage*); | |
| 58 | +extern void dirtyXdata(Memimage*, Rectangle); | |
| 59 | +extern ulong xscreenchan; | |
| 60 | +extern void xfillcolor(Memimage*, Rectangle, ulong); | |
Binary file not shown.
| @@ -0,0 +1,144 @@ | ||
| 1 | +#pragma src "/sys/src/libauth" | |
| 2 | +#pragma lib "libauth.a" | |
| 3 | + | |
| 4 | +/* | |
| 5 | + * Interface for typical callers. | |
| 6 | + */ | |
| 7 | + | |
| 8 | +typedef struct AuthInfo AuthInfo; | |
| 9 | +typedef struct Chalstate Chalstate; | |
| 10 | +typedef struct Chapreply Chapreply; | |
| 11 | +typedef struct MSchapreply MSchapreply; | |
| 12 | +typedef struct UserPasswd UserPasswd; | |
| 13 | +typedef struct AuthRpc AuthRpc; | |
| 14 | + | |
| 15 | +enum | |
| 16 | +{ | |
| 17 | + MAXCHLEN= 256, /* max challenge length */ | |
| 18 | + MAXNAMELEN= 256, /* maximum name length */ | |
| 19 | + MD5LEN= 16, | |
| 20 | + | |
| 21 | + ARok = 0, /* rpc return values */ | |
| 22 | + ARdone, | |
| 23 | + ARerror, | |
| 24 | + ARneedkey, | |
| 25 | + ARbadkey, | |
| 26 | + ARwritenext, | |
| 27 | + ARtoosmall, | |
| 28 | + ARtoobig, | |
| 29 | + ARrpcfailure, | |
| 30 | + ARphase, | |
| 31 | + | |
| 32 | + AuthRpcMax = 4096, | |
| 33 | +}; | |
| 34 | + | |
| 35 | +struct AuthRpc | |
| 36 | +{ | |
| 37 | + int afd; | |
| 38 | + char ibuf[AuthRpcMax]; | |
| 39 | + char obuf[AuthRpcMax]; | |
| 40 | + char *arg; | |
| 41 | + uint narg; | |
| 42 | +}; | |
| 43 | + | |
| 44 | +struct AuthInfo | |
| 45 | +{ | |
| 46 | + char *cuid; /* caller id */ | |
| 47 | + char *suid; /* server id */ | |
| 48 | + char *cap; /* capability (only valid on server side) */ | |
| 49 | + int nsecret; /* length of secret */ | |
| 50 | + uchar *secret; /* secret */ | |
| 51 | +}; | |
| 52 | + | |
| 53 | +struct Chalstate | |
| 54 | +{ | |
| 55 | + char *user; | |
| 56 | + char chal[MAXCHLEN]; | |
| 57 | + int nchal; | |
| 58 | + void *resp; | |
| 59 | + int nresp; | |
| 60 | + | |
| 61 | +/* for implementation only */ | |
| 62 | + int afd; /* to factotum */ | |
| 63 | + AuthRpc *rpc; /* to factotum */ | |
| 64 | + char userbuf[MAXNAMELEN]; /* temp space if needed */ | |
| 65 | + int userinchal; /* user was sent to obtain challenge */ | |
| 66 | +}; | |
| 67 | + | |
| 68 | +struct Chapreply /* for protocol "chap" */ | |
| 69 | +{ | |
| 70 | + uchar id; | |
| 71 | + char resp[MD5LEN]; | |
| 72 | +}; | |
| 73 | + | |
| 74 | +struct MSchapreply /* for protocol "mschap" */ | |
| 75 | +{ | |
| 76 | + char LMresp[24]; /* Lan Manager response */ | |
| 77 | + char NTresp[24]; /* NT response */ | |
| 78 | +}; | |
| 79 | + | |
| 80 | +struct UserPasswd | |
| 81 | +{ | |
| 82 | + char *user; | |
| 83 | + char *passwd; | |
| 84 | +}; | |
| 85 | + | |
| 86 | +extern int newns(char*, char*); | |
| 87 | +extern int addns(char*, char*); | |
| 88 | + | |
| 89 | +extern int noworld(char*); | |
| 90 | +extern int amount(int, char*, int, char*); | |
| 91 | + | |
| 92 | +/* these two may get generalized away -rsc */ | |
| 93 | +extern int login(char*, char*, char*); | |
| 94 | +extern int httpauth(char*, char*); | |
| 95 | + | |
| 96 | +typedef struct Attr Attr; | |
| 97 | +typedef struct String String; | |
| 98 | +enum { | |
| 99 | + AttrNameval, /* name=val -- when matching, must have name=val */ | |
| 100 | + AttrQuery, /* name? -- when matching, must be present */ | |
| 101 | + AttrDefault, /* name:=val -- when matching, if present must match INTERNAL */ | |
| 102 | +}; | |
| 103 | +struct Attr | |
| 104 | +{ | |
| 105 | + int type; | |
| 106 | + Attr *next; | |
| 107 | + char *name; | |
| 108 | + char *val; | |
| 109 | +}; | |
| 110 | + | |
| 111 | +typedef int AuthGetkey(char*); | |
| 112 | + | |
| 113 | +int _attrfmt(Fmt*); | |
| 114 | +Attr *_copyattr(Attr*); | |
| 115 | +Attr *_delattr(Attr*, char*); | |
| 116 | +Attr *_findattr(Attr*, char*); | |
| 117 | +void _freeattr(Attr*); | |
| 118 | +Attr *_mkattr(int, char*, char*, Attr*); | |
| 119 | +Attr *_parseattr(char*); | |
| 120 | +char *_strfindattr(Attr*, char*); | |
| 121 | +#pragma varargck type "A" Attr* | |
| 122 | + | |
| 123 | +extern AuthInfo* fauth_proxy(int, AuthRpc *rpc, AuthGetkey *getkey, char *params); | |
| 124 | +extern AuthInfo* auth_proxy(int fd, AuthGetkey *getkey, char *fmt, ...); | |
| 125 | +extern int auth_getkey(char*); | |
| 126 | +extern int (*amount_getkey)(char*); | |
| 127 | +extern void auth_freeAI(AuthInfo *ai); | |
| 128 | +extern int auth_chuid(AuthInfo *ai, char *ns); | |
| 129 | +extern Chalstate *auth_challenge(char*, ...); | |
| 130 | +extern AuthInfo* auth_response(Chalstate*); | |
| 131 | +extern int auth_respond(void*, uint, char*, uint, void*, uint, AuthGetkey *getkey, char*, ...); | |
| 132 | +extern void auth_freechal(Chalstate*); | |
| 133 | +extern AuthInfo* auth_userpasswd(char *user, char *passwd); | |
| 134 | +extern UserPasswd* auth_getuserpasswd(AuthGetkey *getkey, char*, ...); | |
| 135 | +extern AuthInfo* auth_getinfo(AuthRpc *rpc); | |
| 136 | +extern AuthRpc* auth_allocrpc(int afd); | |
| 137 | +extern Attr* auth_attr(AuthRpc *rpc); | |
| 138 | +extern void auth_freerpc(AuthRpc *rpc); | |
| 139 | +extern uint auth_rpc(AuthRpc *rpc, char *verb, void *a, int n); | |
| 140 | +extern int auth_wep(char*, char*, ...); | |
| 141 | +#pragma varargck argpos auth_proxy 3 | |
| 142 | +#pragma varargck argpos auth_challenge 1 | |
| 143 | +#pragma varargck argpos auth_respond 3 | |
| 144 | +#pragma varargck argpos auth_getuserpasswd 2 | |
| @@ -0,0 +1,166 @@ | ||
| 1 | +#pragma src "/sys/src/libauthsrv" | |
| 2 | +#pragma lib "libauthsrv.a" | |
| 3 | + | |
| 4 | +/* | |
| 5 | + * Interface for talking to authentication server. | |
| 6 | + */ | |
| 7 | +typedef struct Ticket Ticket; | |
| 8 | +typedef struct Ticketreq Ticketreq; | |
| 9 | +typedef struct Authenticator Authenticator; | |
| 10 | +typedef struct Nvrsafe Nvrsafe; | |
| 11 | +typedef struct Passwordreq Passwordreq; | |
| 12 | +typedef struct OChapreply OChapreply; | |
| 13 | +typedef struct OMSchapreply OMSchapreply; | |
| 14 | + | |
| 15 | +enum | |
| 16 | +{ | |
| 17 | + ANAMELEN= 28, /* maximum size of name in previous proto */ | |
| 18 | + AERRLEN= 64, /* maximum size of errstr in previous proto */ | |
| 19 | + DOMLEN= 48, /* length of an authentication domain name */ | |
| 20 | + DESKEYLEN= 7, /* length of a des key for encrypt/decrypt */ | |
| 21 | + CHALLEN= 8, /* length of a plan9 sk1 challenge */ | |
| 22 | + NETCHLEN= 16, /* max network challenge length (used in AS protocol) */ | |
| 23 | + CONFIGLEN= 14, | |
| 24 | + SECRETLEN= 32, /* max length of a secret */ | |
| 25 | + | |
| 26 | + KEYDBOFF= 8, /* length of random data at the start of key file */ | |
| 27 | + OKEYDBLEN= ANAMELEN+DESKEYLEN+4+2, /* length of an entry in old key file */ | |
| 28 | + KEYDBLEN= OKEYDBLEN+SECRETLEN, /* length of an entry in key file */ | |
| 29 | + OMD5LEN= 16, | |
| 30 | +}; | |
| 31 | + | |
| 32 | +/* encryption numberings (anti-replay) */ | |
| 33 | +enum | |
| 34 | +{ | |
| 35 | + AuthTreq=1, /* ticket request */ | |
| 36 | + AuthChal=2, /* challenge box request */ | |
| 37 | + AuthPass=3, /* change password */ | |
| 38 | + AuthOK=4, /* fixed length reply follows */ | |
| 39 | + AuthErr=5, /* error follows */ | |
| 40 | + AuthMod=6, /* modify user */ | |
| 41 | + AuthApop=7, /* apop authentication for pop3 */ | |
| 42 | + AuthOKvar=9, /* variable length reply follows */ | |
| 43 | + AuthChap=10, /* chap authentication for ppp */ | |
| 44 | + AuthMSchap=11, /* MS chap authentication for ppp */ | |
| 45 | + AuthCram=12, /* CRAM verification for IMAP (RFC2195 & rfc2104) */ | |
| 46 | + AuthHttp=13, /* http domain login */ | |
| 47 | + AuthVNC=14, /* VNC server login (deprecated) */ | |
| 48 | + | |
| 49 | + | |
| 50 | + AuthTs=64, /* ticket encrypted with server's key */ | |
| 51 | + AuthTc, /* ticket encrypted with client's key */ | |
| 52 | + AuthAs, /* server generated authenticator */ | |
| 53 | + AuthAc, /* client generated authenticator */ | |
| 54 | + AuthTp, /* ticket encrypted with client's key for password change */ | |
| 55 | + AuthHr, /* http reply */ | |
| 56 | +}; | |
| 57 | + | |
| 58 | +struct Ticketreq | |
| 59 | +{ | |
| 60 | + char type; | |
| 61 | + char authid[ANAMELEN]; /* server's encryption id */ | |
| 62 | + char authdom[DOMLEN]; /* server's authentication domain */ | |
| 63 | + char chal[CHALLEN]; /* challenge from server */ | |
| 64 | + char hostid[ANAMELEN]; /* host's encryption id */ | |
| 65 | + char uid[ANAMELEN]; /* uid of requesting user on host */ | |
| 66 | +}; | |
| 67 | +#define TICKREQLEN (3*ANAMELEN+CHALLEN+DOMLEN+1) | |
| 68 | + | |
| 69 | +struct Ticket | |
| 70 | +{ | |
| 71 | + char num; /* replay protection */ | |
| 72 | + char chal[CHALLEN]; /* server challenge */ | |
| 73 | + char cuid[ANAMELEN]; /* uid on client */ | |
| 74 | + char suid[ANAMELEN]; /* uid on server */ | |
| 75 | + char key[DESKEYLEN]; /* nonce DES key */ | |
| 76 | +}; | |
| 77 | +#define TICKETLEN (CHALLEN+2*ANAMELEN+DESKEYLEN+1) | |
| 78 | + | |
| 79 | +struct Authenticator | |
| 80 | +{ | |
| 81 | + char num; /* replay protection */ | |
| 82 | + char chal[CHALLEN]; | |
| 83 | + ulong id; /* authenticator id, ++'d with each auth */ | |
| 84 | +}; | |
| 85 | +#define AUTHENTLEN (CHALLEN+4+1) | |
| 86 | + | |
| 87 | +struct Passwordreq | |
| 88 | +{ | |
| 89 | + char num; | |
| 90 | + char old[ANAMELEN]; | |
| 91 | + char new[ANAMELEN]; | |
| 92 | + char changesecret; | |
| 93 | + char secret[SECRETLEN]; /* new secret */ | |
| 94 | +}; | |
| 95 | +#define PASSREQLEN (2*ANAMELEN+1+1+SECRETLEN) | |
| 96 | + | |
| 97 | +struct OChapreply | |
| 98 | +{ | |
| 99 | + uchar id; | |
| 100 | + char uid[ANAMELEN]; | |
| 101 | + char resp[OMD5LEN]; | |
| 102 | +}; | |
| 103 | + | |
| 104 | +struct OMSchapreply | |
| 105 | +{ | |
| 106 | + char uid[ANAMELEN]; | |
| 107 | + char LMresp[24]; /* Lan Manager response */ | |
| 108 | + char NTresp[24]; /* NT response */ | |
| 109 | +}; | |
| 110 | + | |
| 111 | +/* | |
| 112 | + * convert to/from wire format | |
| 113 | + */ | |
| 114 | +extern int convT2M(Ticket*, char*, char*); | |
| 115 | +extern void convM2T(char*, Ticket*, char*); | |
| 116 | +extern void convM2Tnoenc(char*, Ticket*); | |
| 117 | +extern int convA2M(Authenticator*, char*, char*); | |
| 118 | +extern void convM2A(char*, Authenticator*, char*); | |
| 119 | +extern int convTR2M(Ticketreq*, char*); | |
| 120 | +extern void convM2TR(char*, Ticketreq*); | |
| 121 | +extern int convPR2M(Passwordreq*, char*, char*); | |
| 122 | +extern void convM2PR(char*, Passwordreq*, char*); | |
| 123 | + | |
| 124 | +/* | |
| 125 | + * convert ascii password to DES key | |
| 126 | + */ | |
| 127 | +extern int opasstokey(char*, char*); | |
| 128 | +extern int passtokey(char*, char*); | |
| 129 | + | |
| 130 | +/* | |
| 131 | + * Nvram interface | |
| 132 | + */ | |
| 133 | +enum { | |
| 134 | + NVwrite = 1<<0, /* always prompt and rewrite nvram */ | |
| 135 | + NVwriteonerr = 1<<1, /* prompt and rewrite nvram when corrupt */ | |
| 136 | +}; | |
| 137 | + | |
| 138 | +struct Nvrsafe | |
| 139 | +{ | |
| 140 | + char machkey[DESKEYLEN]; | |
| 141 | + uchar machsum; | |
| 142 | + char authkey[DESKEYLEN]; | |
| 143 | + uchar authsum; | |
| 144 | + char config[CONFIGLEN]; | |
| 145 | + uchar configsum; | |
| 146 | + char authid[ANAMELEN]; | |
| 147 | + uchar authidsum; | |
| 148 | + char authdom[DOMLEN]; | |
| 149 | + uchar authdomsum; | |
| 150 | +}; | |
| 151 | + | |
| 152 | +extern uchar nvcsum(void*, int); | |
| 153 | +extern int readnvram(Nvrsafe*, int); | |
| 154 | + | |
| 155 | +/* | |
| 156 | + * call up auth server | |
| 157 | + */ | |
| 158 | +extern int authdial(char *netroot, char *authdom); | |
| 159 | + | |
| 160 | +/* | |
| 161 | + * exchange messages with auth server | |
| 162 | + */ | |
| 163 | +extern int _asgetticket(int, char*, char*); | |
| 164 | +extern int _asrdresp(int, char*, int); | |
| 165 | +extern int sslnegotiate(int, Ticket*, char**, char**); | |
| 166 | +extern int srvsslnegotiate(int, Ticket*, char**, char**); | |
| @@ -0,0 +1,6 @@ | ||
| 1 | +struct Cursor | |
| 2 | +{ | |
| 3 | + Point offset; | |
| 4 | + uchar clr[2*16]; | |
| 5 | + uchar set[2*16]; | |
| 6 | +}; | |
| @@ -0,0 +1,519 @@ | ||
| 1 | +#pragma src "/sys/src/libdraw" | |
| 2 | +#pragma lib "libdraw.a" | |
| 3 | + | |
| 4 | +typedef struct Cachefont Cachefont; | |
| 5 | +typedef struct Cacheinfo Cacheinfo; | |
| 6 | +typedef struct Cachesubf Cachesubf; | |
| 7 | +typedef struct Display Display; | |
| 8 | +typedef struct Font Font; | |
| 9 | +typedef struct Fontchar Fontchar; | |
| 10 | +typedef struct Image Image; | |
| 11 | +typedef struct Mouse Mouse; | |
| 12 | +typedef struct Point Point; | |
| 13 | +typedef struct Rectangle Rectangle; | |
| 14 | +typedef struct RGB RGB; | |
| 15 | +typedef struct Screen Screen; | |
| 16 | +typedef struct Subfont Subfont; | |
| 17 | + | |
| 18 | +#pragma varargck type "R" Rectangle | |
| 19 | +#pragma varargck type "P" Point | |
| 20 | +extern int Rfmt(Fmt*); | |
| 21 | +extern int Pfmt(Fmt*); | |
| 22 | + | |
| 23 | +enum | |
| 24 | +{ | |
| 25 | + DOpaque = 0xFFFFFFFF, | |
| 26 | + DTransparent = 0x00000000, /* only useful for allocimage, memfillcolor */ | |
| 27 | + DBlack = 0x000000FF, | |
| 28 | + DWhite = 0xFFFFFFFF, | |
| 29 | + DRed = 0xFF0000FF, | |
| 30 | + DGreen = 0x00FF00FF, | |
| 31 | + DBlue = 0x0000FFFF, | |
| 32 | + DCyan = 0x00FFFFFF, | |
| 33 | + DMagenta = 0xFF00FFFF, | |
| 34 | + DYellow = 0xFFFF00FF, | |
| 35 | + DPaleyellow = 0xFFFFAAFF, | |
| 36 | + DDarkyellow = 0xEEEE9EFF, | |
| 37 | + DDarkgreen = 0x448844FF, | |
| 38 | + DPalegreen = 0xAAFFAAFF, | |
| 39 | + DMedgreen = 0x88CC88FF, | |
| 40 | + DDarkblue = 0x000055FF, | |
| 41 | + DPalebluegreen= 0xAAFFFFFF, | |
| 42 | + DPaleblue = 0x0000BBFF, | |
| 43 | + DBluegreen = 0x008888FF, | |
| 44 | + DGreygreen = 0x55AAAAFF, | |
| 45 | + DPalegreygreen = 0x9EEEEEFF, | |
| 46 | + DYellowgreen = 0x99994CFF, | |
| 47 | + DMedblue = 0x000099FF, | |
| 48 | + DGreyblue = 0x005DBBFF, | |
| 49 | + DPalegreyblue = 0x4993DDFF, | |
| 50 | + DPurpleblue = 0x8888CCFF, | |
| 51 | + | |
| 52 | + DNotacolor = 0xFFFFFF00, | |
| 53 | + DNofill = DNotacolor, | |
| 54 | + | |
| 55 | +}; | |
| 56 | + | |
| 57 | +enum | |
| 58 | +{ | |
| 59 | + Displaybufsize = 8000, | |
| 60 | + ICOSSCALE = 1024, | |
| 61 | + Borderwidth = 4, | |
| 62 | +}; | |
| 63 | + | |
| 64 | +enum | |
| 65 | +{ | |
| 66 | + /* refresh methods */ | |
| 67 | + Refbackup = 0, | |
| 68 | + Refnone = 1, | |
| 69 | + Refmesg = 2 | |
| 70 | +}; | |
| 71 | +#define NOREFRESH ((void*)-1) | |
| 72 | + | |
| 73 | +enum | |
| 74 | +{ | |
| 75 | + /* line ends */ | |
| 76 | + Endsquare = 0, | |
| 77 | + Enddisc = 1, | |
| 78 | + Endarrow = 2, | |
| 79 | + Endmask = 0x1F | |
| 80 | +}; | |
| 81 | + | |
| 82 | +#define ARROW(a, b, c) (Endarrow|((a)<<5)|((b)<<14)|((c)<<23)) | |
| 83 | + | |
| 84 | +typedef enum | |
| 85 | +{ | |
| 86 | + /* Porter-Duff compositing operators */ | |
| 87 | + Clear = 0, | |
| 88 | + | |
| 89 | + SinD = 8, | |
| 90 | + DinS = 4, | |
| 91 | + SoutD = 2, | |
| 92 | + DoutS = 1, | |
| 93 | + | |
| 94 | + S = SinD|SoutD, | |
| 95 | + SoverD = SinD|SoutD|DoutS, | |
| 96 | + SatopD = SinD|DoutS, | |
| 97 | + SxorD = SoutD|DoutS, | |
| 98 | + | |
| 99 | + D = DinS|DoutS, | |
| 100 | + DoverS = DinS|DoutS|SoutD, | |
| 101 | + DatopS = DinS|SoutD, | |
| 102 | + DxorS = DoutS|SoutD, /* == SxorD */ | |
| 103 | + | |
| 104 | + Ncomp = 12, | |
| 105 | +} Drawop; | |
| 106 | + | |
| 107 | +/* | |
| 108 | + * image channel descriptors | |
| 109 | + */ | |
| 110 | +enum { | |
| 111 | + CRed = 0, | |
| 112 | + CGreen, | |
| 113 | + CBlue, | |
| 114 | + CGrey, | |
| 115 | + CAlpha, | |
| 116 | + CMap, | |
| 117 | + CIgnore, | |
| 118 | + NChan, | |
| 119 | +}; | |
| 120 | + | |
| 121 | +#define __DC(type, nbits) ((((type)&15)<<4)|((nbits)&15)) | |
| 122 | +#define CHAN1(a,b) __DC(a,b) | |
| 123 | +#define CHAN2(a,b,c,d) (CHAN1((a),(b))<<8|__DC((c),(d))) | |
| 124 | +#define CHAN3(a,b,c,d,e,f) (CHAN2((a),(b),(c),(d))<<8|__DC((e),(f))) | |
| 125 | +#define CHAN4(a,b,c,d,e,f,g,h) (CHAN3((a),(b),(c),(d),(e),(f))<<8|__DC((g),(h))) | |
| 126 | + | |
| 127 | +#define NBITS(c) ((c)&15) | |
| 128 | +#define TYPE(c) (((c)>>4)&15) | |
| 129 | + | |
| 130 | +enum { | |
| 131 | + GREY1 = CHAN1(CGrey, 1), | |
| 132 | + GREY2 = CHAN1(CGrey, 2), | |
| 133 | + GREY4 = CHAN1(CGrey, 4), | |
| 134 | + GREY8 = CHAN1(CGrey, 8), | |
| 135 | + CMAP8 = CHAN1(CMap, 8), | |
| 136 | + RGB15 = CHAN4(CIgnore, 1, CRed, 5, CGreen, 5, CBlue, 5), | |
| 137 | + RGB16 = CHAN3(CRed, 5, CGreen, 6, CBlue, 5), | |
| 138 | + RGB24 = CHAN3(CRed, 8, CGreen, 8, CBlue, 8), | |
| 139 | + BGR24 = CHAN3(CBlue, 8, CGreen, 8, CRed, 8), | |
| 140 | + RGBA32 = CHAN4(CRed, 8, CGreen, 8, CBlue, 8, CAlpha, 8), | |
| 141 | + ARGB32 = CHAN4(CAlpha, 8, CRed, 8, CGreen, 8, CBlue, 8), /* stupid VGAs */ | |
| 142 | + XRGB32 = CHAN4(CIgnore, 8, CRed, 8, CGreen, 8, CBlue, 8), | |
| 143 | + XBGR32 = CHAN4(CIgnore, 8, CBlue, 8, CGreen, 8, CRed, 8), | |
| 144 | +}; | |
| 145 | + | |
| 146 | +extern char* chantostr(char*, ulong); | |
| 147 | +extern ulong strtochan(char*); | |
| 148 | +extern int chantodepth(ulong); | |
| 149 | + | |
| 150 | +struct Point | |
| 151 | +{ | |
| 152 | + int x; | |
| 153 | + int y; | |
| 154 | +}; | |
| 155 | + | |
| 156 | +struct Rectangle | |
| 157 | +{ | |
| 158 | + Point min; | |
| 159 | + Point max; | |
| 160 | +}; | |
| 161 | + | |
| 162 | +typedef void (*Reffn)(Image*, Rectangle, void*); | |
| 163 | + | |
| 164 | +struct Screen | |
| 165 | +{ | |
| 166 | + Display *display; /* display holding data */ | |
| 167 | + int id; /* id of system-held Screen */ | |
| 168 | + Image *image; /* unused; for reference only */ | |
| 169 | + Image *fill; /* color to paint behind windows */ | |
| 170 | +}; | |
| 171 | + | |
| 172 | +struct Display | |
| 173 | +{ | |
| 174 | + QLock qlock; | |
| 175 | + int locking; /*program is using lockdisplay */ | |
| 176 | + int dirno; | |
| 177 | + int fd; | |
| 178 | + int reffd; | |
| 179 | + int ctlfd; | |
| 180 | + int imageid; | |
| 181 | + int local; | |
| 182 | + void (*error)(Display*, char*); | |
| 183 | + char *devdir; | |
| 184 | + char *windir; | |
| 185 | + char oldlabel[64]; | |
| 186 | + ulong dataqid; | |
| 187 | + Image *white; | |
| 188 | + Image *black; | |
| 189 | + Image *opaque; | |
| 190 | + Image *transparent; | |
| 191 | + Image *image; | |
| 192 | + uchar *buf; | |
| 193 | + int bufsize; | |
| 194 | + uchar *bufp; | |
| 195 | + Font *defaultfont; | |
| 196 | + Subfont *defaultsubfont; | |
| 197 | + Image *windows; | |
| 198 | + Image *screenimage; | |
| 199 | + int _isnewdisplay; | |
| 200 | +}; | |
| 201 | + | |
| 202 | +struct Image | |
| 203 | +{ | |
| 204 | + Display *display; /* display holding data */ | |
| 205 | + int id; /* id of system-held Image */ | |
| 206 | + Rectangle r; /* rectangle in data area, local coords */ | |
| 207 | + Rectangle clipr; /* clipping region */ | |
| 208 | + int depth; /* number of bits per pixel */ | |
| 209 | + ulong chan; | |
| 210 | + int repl; /* flag: data replicates to tile clipr */ | |
| 211 | + Screen *screen; /* 0 if not a window */ | |
| 212 | + Image *next; /* next in list of windows */ | |
| 213 | +}; | |
| 214 | + | |
| 215 | +struct RGB | |
| 216 | +{ | |
| 217 | + ulong red; | |
| 218 | + ulong green; | |
| 219 | + ulong blue; | |
| 220 | +}; | |
| 221 | + | |
| 222 | +/* | |
| 223 | + * Subfonts | |
| 224 | + * | |
| 225 | + * given char c, Subfont *f, Fontchar *i, and Point p, one says | |
| 226 | + * i = f->info+c; | |
| 227 | + * draw(b, Rect(p.x+i->left, p.y+i->top, | |
| 228 | + * p.x+i->left+((i+1)->x-i->x), p.y+i->bottom), | |
| 229 | + * color, f->bits, Pt(i->x, i->top)); | |
| 230 | + * p.x += i->width; | |
| 231 | + * to draw characters in the specified color (itself an Image) in Image b. | |
| 232 | + */ | |
| 233 | + | |
| 234 | +struct Fontchar | |
| 235 | +{ | |
| 236 | + int x; /* left edge of bits */ | |
| 237 | + uchar top; /* first non-zero scan-line */ | |
| 238 | + uchar bottom; /* last non-zero scan-line + 1 */ | |
| 239 | + char left; /* offset of baseline */ | |
| 240 | + uchar width; /* width of baseline */ | |
| 241 | +}; | |
| 242 | + | |
| 243 | +struct Subfont | |
| 244 | +{ | |
| 245 | + char *name; | |
| 246 | + short n; /* number of chars in font */ | |
| 247 | + uchar height; /* height of image */ | |
| 248 | + char ascent; /* top of image to baseline */ | |
| 249 | + Fontchar *info; /* n+1 character descriptors */ | |
| 250 | + Image *bits; /* of font */ | |
| 251 | + int ref; | |
| 252 | +}; | |
| 253 | + | |
| 254 | +enum | |
| 255 | +{ | |
| 256 | + /* starting values */ | |
| 257 | + LOG2NFCACHE = 6, | |
| 258 | + NFCACHE = (1<<LOG2NFCACHE), /* #chars cached */ | |
| 259 | + NFLOOK = 5, /* #chars to scan in cache */ | |
| 260 | + NFSUBF = 2, /* #subfonts to cache */ | |
| 261 | + /* max value */ | |
| 262 | + MAXFCACHE = 1024+NFLOOK, /* upper limit */ | |
| 263 | + MAXSUBF = 50, /* generous upper limit */ | |
| 264 | + /* deltas */ | |
| 265 | + DSUBF = 4, | |
| 266 | + /* expiry ages */ | |
| 267 | + SUBFAGE = 10000, | |
| 268 | + CACHEAGE = 10000 | |
| 269 | +}; | |
| 270 | + | |
| 271 | +struct Cachefont | |
| 272 | +{ | |
| 273 | + Rune min; /* lowest rune value to be taken from subfont */ | |
| 274 | + Rune max; /* highest rune value+1 to be taken from subfont */ | |
| 275 | + int offset; /* position in subfont of character at min */ | |
| 276 | + char *name; /* stored in font */ | |
| 277 | + char *subfontname; /* to access subfont */ | |
| 278 | +}; | |
| 279 | + | |
| 280 | +struct Cacheinfo | |
| 281 | +{ | |
| 282 | + ushort x; /* left edge of bits */ | |
| 283 | + uchar width; /* width of baseline */ | |
| 284 | + schar left; /* offset of baseline */ | |
| 285 | + Rune value; /* value of character at this slot in cache */ | |
| 286 | + ushort age; | |
| 287 | +}; | |
| 288 | + | |
| 289 | +struct Cachesubf | |
| 290 | +{ | |
| 291 | + ulong age; /* for replacement */ | |
| 292 | + Cachefont *cf; /* font info that owns us */ | |
| 293 | + Subfont *f; /* attached subfont */ | |
| 294 | +}; | |
| 295 | + | |
| 296 | +struct Font | |
| 297 | +{ | |
| 298 | + char *name; | |
| 299 | + Display *display; | |
| 300 | + short height; /* max height of image, interline spacing */ | |
| 301 | + short ascent; /* top of image to baseline */ | |
| 302 | + short width; /* widest so far; used in caching only */ | |
| 303 | + short nsub; /* number of subfonts */ | |
| 304 | + ulong age; /* increasing counter; used for LRU */ | |
| 305 | + int maxdepth; /* maximum depth of all loaded subfonts */ | |
| 306 | + int ncache; /* size of cache */ | |
| 307 | + int nsubf; /* size of subfont list */ | |
| 308 | + Cacheinfo *cache; | |
| 309 | + Cachesubf *subf; | |
| 310 | + Cachefont **sub; /* as read from file */ | |
| 311 | + Image *cacheimage; | |
| 312 | +}; | |
| 313 | + | |
| 314 | +#define Dx(r) ((r).max.x-(r).min.x) | |
| 315 | +#define Dy(r) ((r).max.y-(r).min.y) | |
| 316 | + | |
| 317 | +/* | |
| 318 | + * Image management | |
| 319 | + */ | |
| 320 | +extern Image* _allocimage(Image*, Display*, Rectangle, ulong, int, ulong, int, int); | |
| 321 | +extern Image* allocimage(Display*, Rectangle, ulong, int, ulong); | |
| 322 | +extern uchar* bufimage(Display*, int); | |
| 323 | +extern int bytesperline(Rectangle, int); | |
| 324 | +extern void closedisplay(Display*); | |
| 325 | +extern void drawerror(Display*, char*); | |
| 326 | +extern int flushimage(Display*, int); | |
| 327 | +extern int freeimage(Image*); | |
| 328 | +extern int _freeimage1(Image*); | |
| 329 | +extern int geninitdraw(char*, void(*)(Display*, char*), char*, char*, char*, int); | |
| 330 | +extern int initdraw(void(*)(Display*, char*), char*, char*); | |
| 331 | +extern int newwindow(char*); | |
| 332 | +extern Display* initdisplay(char*, char*, void(*)(Display*, char*)); | |
| 333 | +extern int loadimage(Image*, Rectangle, uchar*, int); | |
| 334 | +extern int cloadimage(Image*, Rectangle, uchar*, int); | |
| 335 | +extern int getwindow(Display*, int); | |
| 336 | +extern int gengetwindow(Display*, char*, Image**, Screen**, int); | |
| 337 | +extern Image* readimage(Display*, int, int); | |
| 338 | +extern Image* creadimage(Display*, int, int); | |
| 339 | +extern int unloadimage(Image*, Rectangle, uchar*, int); | |
| 340 | +extern int wordsperline(Rectangle, int); | |
| 341 | +extern int writeimage(int, Image*, int); | |
| 342 | +extern Image* namedimage(Display*, char*); | |
| 343 | +extern int nameimage(Image*, char*, int); | |
| 344 | +extern Image* allocimagemix(Display*, ulong, ulong); | |
| 345 | + | |
| 346 | +/* | |
| 347 | + * Colors | |
| 348 | + */ | |
| 349 | +extern void readcolmap(Display*, RGB*); | |
| 350 | +extern void writecolmap(Display*, RGB*); | |
| 351 | +extern ulong setalpha(ulong, uchar); | |
| 352 | + | |
| 353 | +/* | |
| 354 | + * Windows | |
| 355 | + */ | |
| 356 | +extern Screen* allocscreen(Image*, Image*, int); | |
| 357 | +extern Image* _allocwindow(Image*, Screen*, Rectangle, int, ulong); | |
| 358 | +extern Image* allocwindow(Screen*, Rectangle, int, ulong); | |
| 359 | +extern void bottomnwindows(Image**, int); | |
| 360 | +extern void bottomwindow(Image*); | |
| 361 | +extern int freescreen(Screen*); | |
| 362 | +extern Screen* publicscreen(Display*, int, ulong); | |
| 363 | +extern void topnwindows(Image**, int); | |
| 364 | +extern void topwindow(Image*); | |
| 365 | +extern int originwindow(Image*, Point, Point); | |
| 366 | + | |
| 367 | +/* | |
| 368 | + * Geometry | |
| 369 | + */ | |
| 370 | +extern Point Pt(int, int); | |
| 371 | +extern Rectangle Rect(int, int, int, int); | |
| 372 | +extern Rectangle Rpt(Point, Point); | |
| 373 | +extern Point addpt(Point, Point); | |
| 374 | +extern Point subpt(Point, Point); | |
| 375 | +extern Point divpt(Point, int); | |
| 376 | +extern Point mulpt(Point, int); | |
| 377 | +extern int eqpt(Point, Point); | |
| 378 | +extern int eqrect(Rectangle, Rectangle); | |
| 379 | +extern Rectangle insetrect(Rectangle, int); | |
| 380 | +extern Rectangle rectaddpt(Rectangle, Point); | |
| 381 | +extern Rectangle rectsubpt(Rectangle, Point); | |
| 382 | +extern Rectangle canonrect(Rectangle); | |
| 383 | +extern int rectXrect(Rectangle, Rectangle); | |
| 384 | +extern int rectinrect(Rectangle, Rectangle); | |
| 385 | +extern void combinerect(Rectangle*, Rectangle); | |
| 386 | +extern int rectclip(Rectangle*, Rectangle); | |
| 387 | +extern int ptinrect(Point, Rectangle); | |
| 388 | +extern void replclipr(Image*, int, Rectangle); | |
| 389 | +extern int drawreplxy(int, int, int); /* used to be drawsetxy */ | |
| 390 | +extern Point drawrepl(Rectangle, Point); | |
| 391 | +extern int rgb2cmap(int, int, int); | |
| 392 | +extern int cmap2rgb(int); | |
| 393 | +extern int cmap2rgba(int); | |
| 394 | +extern void icossin(int, int*, int*); | |
| 395 | +extern void icossin2(int, int, int*, int*); | |
| 396 | + | |
| 397 | +/* | |
| 398 | + * Graphics | |
| 399 | + */ | |
| 400 | +extern void draw(Image*, Rectangle, Image*, Image*, Point); | |
| 401 | +extern void drawop(Image*, Rectangle, Image*, Image*, Point, Drawop); | |
| 402 | +extern void gendraw(Image*, Rectangle, Image*, Point, Image*, Point); | |
| 403 | +extern void gendrawop(Image*, Rectangle, Image*, Point, Image*, Point, Drawop); | |
| 404 | +extern void line(Image*, Point, Point, int, int, int, Image*, Point); | |
| 405 | +extern void lineop(Image*, Point, Point, int, int, int, Image*, Point, Drawop); | |
| 406 | +extern void poly(Image*, Point*, int, int, int, int, Image*, Point); | |
| 407 | +extern void polyop(Image*, Point*, int, int, int, int, Image*, Point, Drawop); | |
| 408 | +extern void fillpoly(Image*, Point*, int, int, Image*, Point); | |
| 409 | +extern void fillpolyop(Image*, Point*, int, int, Image*, Point, Drawop); | |
| 410 | +extern Point string(Image*, Point, Image*, Point, Font*, char*); | |
| 411 | +extern Point stringop(Image*, Point, Image*, Point, Font*, char*, Drawop); | |
| 412 | +extern Point stringn(Image*, Point, Image*, Point, Font*, char*, int); | |
| 413 | +extern Point stringnop(Image*, Point, Image*, Point, Font*, char*, int, Drawop); | |
| 414 | +extern Point runestring(Image*, Point, Image*, Point, Font*, Rune*); | |
| 415 | +extern Point runestringop(Image*, Point, Image*, Point, Font*, Rune*, Drawop); | |
| 416 | +extern Point runestringn(Image*, Point, Image*, Point, Font*, Rune*, int); | |
| 417 | +extern Point runestringnop(Image*, Point, Image*, Point, Font*, Rune*, int, Drawop); | |
| 418 | +extern Point stringbg(Image*, Point, Image*, Point, Font*, char*, Image*, Point); | |
| 419 | +extern Point stringbgop(Image*, Point, Image*, Point, Font*, char*, Image*, Point, Drawop); | |
| 420 | +extern Point stringnbg(Image*, Point, Image*, Point, Font*, char*, int, Image*, Point); | |
| 421 | +extern Point stringnbgop(Image*, Point, Image*, Point, Font*, char*, int, Image*, Point, Drawop); | |
| 422 | +extern Point runestringbg(Image*, Point, Image*, Point, Font*, Rune*, Image*, Point); | |
| 423 | +extern Point runestringbgop(Image*, Point, Image*, Point, Font*, Rune*, Image*, Point, Drawop); | |
| 424 | +extern Point runestringnbg(Image*, Point, Image*, Point, Font*, Rune*, int, Image*, Point); | |
| 425 | +extern Point runestringnbgop(Image*, Point, Image*, Point, Font*, Rune*, int, Image*, Point, Drawop); | |
| 426 | +extern Point _string(Image*, Point, Image*, Point, Font*, char*, Rune*, int, Rectangle, Image*, Point, Drawop); | |
| 427 | +extern Point stringsubfont(Image*, Point, Image*, Subfont*, char*); | |
| 428 | +extern int bezier(Image*, Point, Point, Point, Point, int, int, int, Image*, Point); | |
| 429 | +extern int bezierop(Image*, Point, Point, Point, Point, int, int, int, Image*, Point, Drawop); | |
| 430 | +extern int bezspline(Image*, Point*, int, int, int, int, Image*, Point); | |
| 431 | +extern int bezsplineop(Image*, Point*, int, int, int, int, Image*, Point, Drawop); | |
| 432 | +extern int bezsplinepts(Point*, int, Point**); | |
| 433 | +extern int fillbezier(Image*, Point, Point, Point, Point, int, Image*, Point); | |
| 434 | +extern int fillbezierop(Image*, Point, Point, Point, Point, int, Image*, Point, Drawop); | |
| 435 | +extern int fillbezspline(Image*, Point*, int, int, Image*, Point); | |
| 436 | +extern int fillbezsplineop(Image*, Point*, int, int, Image*, Point, Drawop); | |
| 437 | +extern void ellipse(Image*, Point, int, int, int, Image*, Point); | |
| 438 | +extern void ellipseop(Image*, Point, int, int, int, Image*, Point, Drawop); | |
| 439 | +extern void fillellipse(Image*, Point, int, int, Image*, Point); | |
| 440 | +extern void fillellipseop(Image*, Point, int, int, Image*, Point, Drawop); | |
| 441 | +extern void arc(Image*, Point, int, int, int, Image*, Point, int, int); | |
| 442 | +extern void arcop(Image*, Point, int, int, int, Image*, Point, int, int, Drawop); | |
| 443 | +extern void fillarc(Image*, Point, int, int, Image*, Point, int, int); | |
| 444 | +extern void fillarcop(Image*, Point, int, int, Image*, Point, int, int, Drawop); | |
| 445 | +extern void border(Image*, Rectangle, int, Image*, Point); | |
| 446 | +extern void borderop(Image*, Rectangle, int, Image*, Point, Drawop); | |
| 447 | + | |
| 448 | +/* | |
| 449 | + * Font management | |
| 450 | + */ | |
| 451 | +extern Font* openfont(Display*, char*); | |
| 452 | +extern Font* buildfont(Display*, char*, char*); | |
| 453 | +extern void freefont(Font*); | |
| 454 | +extern Font* mkfont(Subfont*, Rune); | |
| 455 | +extern int cachechars(Font*, char**, Rune**, ushort*, int, int*, char**); | |
| 456 | +extern void agefont(Font*); | |
| 457 | +extern Subfont* allocsubfont(char*, int, int, int, Fontchar*, Image*); | |
| 458 | +extern Subfont* lookupsubfont(Display*, char*); | |
| 459 | +extern void installsubfont(char*, Subfont*); | |
| 460 | +extern void uninstallsubfont(Subfont*); | |
| 461 | +extern void freesubfont(Subfont*); | |
| 462 | +extern Subfont* readsubfont(Display*, char*, int, int); | |
| 463 | +extern Subfont* readsubfonti(Display*, char*, int, Image*, int); | |
| 464 | +extern int writesubfont(int, Subfont*); | |
| 465 | +extern void _unpackinfo(Fontchar*, uchar*, int); | |
| 466 | +extern Point stringsize(Font*, char*); | |
| 467 | +extern int stringwidth(Font*, char*); | |
| 468 | +extern int stringnwidth(Font*, char*, int); | |
| 469 | +extern Point runestringsize(Font*, Rune*); | |
| 470 | +extern int runestringwidth(Font*, Rune*); | |
| 471 | +extern int runestringnwidth(Font*, Rune*, int); | |
| 472 | +extern Point strsubfontwidth(Subfont*, char*); | |
| 473 | +extern int loadchar(Font*, Rune, Cacheinfo*, int, int, char**); | |
| 474 | +extern char* subfontname(char*, char*, int); | |
| 475 | +extern Subfont* _getsubfont(Display*, char*); | |
| 476 | +extern Subfont* getdefont(Display*); | |
| 477 | +extern void lockdisplay(Display*); | |
| 478 | +extern void unlockdisplay(Display*); | |
| 479 | +extern int drawlsetrefresh(ulong, int, void*, void*); | |
| 480 | + | |
| 481 | +/* | |
| 482 | + * Predefined | |
| 483 | + */ | |
| 484 | +extern uchar defontdata[]; | |
| 485 | +extern int sizeofdefont; | |
| 486 | +extern Point ZP; | |
| 487 | +extern Rectangle ZR; | |
| 488 | + | |
| 489 | +/* | |
| 490 | + * Set up by initdraw() | |
| 491 | + */ | |
| 492 | +extern Display *display; | |
| 493 | +extern Font *font; | |
| 494 | +/* extern Image *screen; */ | |
| 495 | +extern Screen *_screen; | |
| 496 | +extern int _cursorfd; | |
| 497 | +extern int _drawdebug; /* set to 1 to see errors from flushimage */ | |
| 498 | +extern void _setdrawop(Display*, Drawop); | |
| 499 | + | |
| 500 | +#define BGSHORT(p) (((p)[0]<<0) | ((p)[1]<<8)) | |
| 501 | +#define BGLONG(p) ((BGSHORT(p)<<0) | (BGSHORT(p+2)<<16)) | |
| 502 | +#define BPSHORT(p, v) ((p)[0]=(v), (p)[1]=((v)>>8)) | |
| 503 | +#define BPLONG(p, v) (BPSHORT(p, (v)), BPSHORT(p+2, (v)>>16)) | |
| 504 | + | |
| 505 | +/* | |
| 506 | + * Compressed image file parameters and helper routines | |
| 507 | + */ | |
| 508 | +#define NMATCH 3 /* shortest match possible */ | |
| 509 | +#define NRUN (NMATCH+31) /* longest match possible */ | |
| 510 | +#define NMEM 1024 /* window size */ | |
| 511 | +#define NDUMP 128 /* maximum length of dump */ | |
| 512 | +#define NCBLOCK 6000 /* size of compressed blocks */ | |
| 513 | +extern void _twiddlecompressed(uchar*, int); | |
| 514 | +extern int _compblocksize(Rectangle, int); | |
| 515 | + | |
| 516 | +/* XXX backwards helps; should go */ | |
| 517 | +extern int log2[]; | |
| 518 | +extern ulong drawld2chan[]; | |
| 519 | +extern void drawsetdebug(int); | |
| @@ -0,0 +1,10 @@ | ||
| 1 | +#if defined(linux) || defined(IRIX) || defined(SOLARIS) || defined(OSF1) || defined(__FreeBSD__) || defined(__APPLE__) | |
| 2 | +# include "unix.h" | |
| 3 | +# ifdef __APPLE__ | |
| 4 | +# define panic dt_panic | |
| 5 | +# endif | |
| 6 | +#elif defined(WINDOWS) | |
| 7 | +# include "winduhz.h" | |
| 8 | +#else | |
| 9 | +# error "Define an OS" | |
| 10 | +#endif | |
| @@ -0,0 +1,110 @@ | ||
| 1 | +#define VERSION9P "9P2000" | |
| 2 | + | |
| 3 | +#define MAXWELEM 16 | |
| 4 | + | |
| 5 | +typedef | |
| 6 | +struct Fcall | |
| 7 | +{ | |
| 8 | + uchar type; | |
| 9 | + u32int fid; | |
| 10 | + ushort tag; | |
| 11 | + u32int msize; /* Tversion, Rversion */ | |
| 12 | + char *version; /* Tversion, Rversion */ | |
| 13 | + ushort oldtag; /* Tflush */ | |
| 14 | + char *ename; /* Rerror */ | |
| 15 | + Qid qid; /* Rattach, Ropen, Rcreate */ | |
| 16 | + u32int iounit; /* Ropen, Rcreate */ | |
| 17 | + Qid aqid; /* Rauth */ | |
| 18 | + u32int afid; /* Tauth, Tattach */ | |
| 19 | + char *uname; /* Tauth, Tattach */ | |
| 20 | + char *aname; /* Tauth, Tattach */ | |
| 21 | + u32int perm; /* Tcreate */ | |
| 22 | + char *name; /* Tcreate */ | |
| 23 | + uchar mode; /* Tcreate, Topen */ | |
| 24 | + u32int newfid; /* Twalk */ | |
| 25 | + ushort nwname; /* Twalk */ | |
| 26 | + char *wname[MAXWELEM]; /* Twalk */ | |
| 27 | + ushort nwqid; /* Rwalk */ | |
| 28 | + Qid wqid[MAXWELEM]; /* Rwalk */ | |
| 29 | + vlong offset; /* Tread, Twrite */ | |
| 30 | + u32int count; /* Tread, Twrite, Rread */ | |
| 31 | + char *data; /* Twrite, Rread */ | |
| 32 | + ushort nstat; /* Twstat, Rstat */ | |
| 33 | + uchar *stat; /* Twstat, Rstat */ | |
| 34 | +} Fcall; | |
| 35 | + | |
| 36 | + | |
| 37 | +#define GBIT8(p) ((p)[0]) | |
| 38 | +#define GBIT16(p) ((p)[0]|((p)[1]<<8)) | |
| 39 | +#define GBIT32(p) ((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)) | |
| 40 | +#define GBIT64(p) ((vlong)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)) |\ | |
| 41 | + ((vlong)((p)[4]|((p)[5]<<8)|((p)[6]<<16)|((p)[7]<<24)) << 32)) | |
| 42 | + | |
| 43 | +#define PBIT8(p,v) (p)[0]=(v) | |
| 44 | +#define PBIT16(p,v) (p)[0]=(v);(p)[1]=(v)>>8 | |
| 45 | +#define PBIT32(p,v) (p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24 | |
| 46 | +#define PBIT64(p,v) (p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24;\ | |
| 47 | + (p)[4]=(v)>>32;(p)[5]=(v)>>40;(p)[6]=(v)>>48;(p)[7]=(v)>>56 | |
| 48 | + | |
| 49 | +#define BIT8SZ 1 | |
| 50 | +#define BIT16SZ 2 | |
| 51 | +#define BIT32SZ 4 | |
| 52 | +#define BIT64SZ 8 | |
| 53 | +#define QIDSZ (BIT8SZ+BIT32SZ+BIT64SZ) | |
| 54 | + | |
| 55 | +/* STATFIXLEN includes leading 16-bit count */ | |
| 56 | +/* The count, however, excludes itself; total size is BIT16SZ+count */ | |
| 57 | +#define STATFIXLEN (BIT16SZ+QIDSZ+5*BIT16SZ+4*BIT32SZ+1*BIT64SZ) /* amount of fixed length data in a stat buffer */ | |
| 58 | + | |
| 59 | +#define NOTAG (ushort)~0U /* Dummy tag */ | |
| 60 | +#define NOFID (u32int)~0U /* Dummy fid */ | |
| 61 | +#define IOHDRSZ 24 /* ample room for Twrite/Rread header (iounit) */ | |
| 62 | + | |
| 63 | +enum | |
| 64 | +{ | |
| 65 | + Tversion = 100, | |
| 66 | + Rversion, | |
| 67 | + Tauth = 102, | |
| 68 | + Rauth, | |
| 69 | + Tattach = 104, | |
| 70 | + Rattach, | |
| 71 | + Terror = 106, /* illegal */ | |
| 72 | + Rerror, | |
| 73 | + Tflush = 108, | |
| 74 | + Rflush, | |
| 75 | + Twalk = 110, | |
| 76 | + Rwalk, | |
| 77 | + Topen = 112, | |
| 78 | + Ropen, | |
| 79 | + Tcreate = 114, | |
| 80 | + Rcreate, | |
| 81 | + Tread = 116, | |
| 82 | + Rread, | |
| 83 | + Twrite = 118, | |
| 84 | + Rwrite, | |
| 85 | + Tclunk = 120, | |
| 86 | + Rclunk, | |
| 87 | + Tremove = 122, | |
| 88 | + Rremove, | |
| 89 | + Tstat = 124, | |
| 90 | + Rstat, | |
| 91 | + Twstat = 126, | |
| 92 | + Rwstat, | |
| 93 | + Tmax, | |
| 94 | +}; | |
| 95 | + | |
| 96 | +uint convM2S(uchar*, uint, Fcall*); | |
| 97 | +uint convS2M(Fcall*, uchar*, uint); | |
| 98 | +uint sizeS2M(Fcall*); | |
| 99 | + | |
| 100 | +int statcheck(uchar *abuf, uint nbuf); | |
| 101 | +uint convM2D(uchar*, uint, Dir*, char*); | |
| 102 | +uint convD2M(Dir*, uchar*, uint); | |
| 103 | +uint sizeD2M(Dir*); | |
| 104 | + | |
| 105 | +int fcallfmt(Fmt*); | |
| 106 | +int dirfmt(Fmt*); | |
| 107 | +int dirmodefmt(Fmt*); | |
| 108 | + | |
| 109 | +int read9pmsg(int, void*, uint); | |
| 110 | + | |
| @@ -0,0 +1,42 @@ | ||
| 1 | +#pragma src "/sys/src/libdraw" | |
| 2 | +#pragma lib "libdraw.a" | |
| 3 | + | |
| 4 | +typedef struct Keyboardctl Keyboardctl; | |
| 5 | +typedef struct Channel Channel; | |
| 6 | + | |
| 7 | +struct Keyboardctl | |
| 8 | +{ | |
| 9 | + Channel *c; /* chan(Rune)[20] */ | |
| 10 | + | |
| 11 | + char *file; | |
| 12 | + int consfd; /* to cons file */ | |
| 13 | + int ctlfd; /* to ctl file */ | |
| 14 | + int pid; /* of slave proc */ | |
| 15 | +}; | |
| 16 | + | |
| 17 | + | |
| 18 | +extern Keyboardctl* initkeyboard(char*); | |
| 19 | +extern int ctlkeyboard(Keyboardctl*, char*); | |
| 20 | +extern void closekeyboard(Keyboardctl*); | |
| 21 | + | |
| 22 | +enum { | |
| 23 | + KF= 0xF000, /* Rune: beginning of private Unicode space */ | |
| 24 | + Spec= 0xF800, | |
| 25 | + /* KF|1, KF|2, ..., KF|0xC is F1, F2, ..., F12 */ | |
| 26 | + Khome= KF|0x0D, | |
| 27 | + Kup= KF|0x0E, | |
| 28 | + Kpgup= KF|0x0F, | |
| 29 | + Kprint= KF|0x10, | |
| 30 | + Kleft= KF|0x11, | |
| 31 | + Kright= KF|0x12, | |
| 32 | + Kdown= Spec|0x00, | |
| 33 | + Kview= Spec|0x00, | |
| 34 | + Kpgdown= KF|0x13, | |
| 35 | + Kins= KF|0x14, | |
| 36 | + Kend= KF|0x18, | |
| 37 | + | |
| 38 | + Kalt= KF|0x15, | |
| 39 | + Kshift= KF|0x16, | |
| 40 | + Kctl= KF|0x17, | |
| 41 | +}; | |
| 42 | + | |
| @@ -0,0 +1,246 @@ | ||
| 1 | +/* avoid name conflicts */ | |
| 2 | +#define accept pm_accept | |
| 3 | +#define listen pm_listen | |
| 4 | +#define sleep ksleep | |
| 5 | +#define wakeup kwakeup | |
| 6 | +#define strtod libstrtod | |
| 7 | +#define pow10 libpow10 | |
| 8 | + | |
| 9 | +/* conflicts on some os's */ | |
| 10 | +#define encrypt libencrypt | |
| 11 | +#define decrypt libdecrypt | |
| 12 | +#define oserror liboserror | |
| 13 | +#define clone libclone | |
| 14 | +#define atexit libatexit | |
| 15 | +#define log2 liblog2 | |
| 16 | +#define log liblog | |
| 17 | +#define reboot libreboot | |
| 18 | +#define srand dtsrand | |
| 19 | +#define rand dtrand | |
| 20 | +#define nrand dtnrand | |
| 21 | +#define lrand dtlrand | |
| 22 | +#define lnrand dtlnrand | |
| 23 | +#undef timeradd | |
| 24 | +#define timeradd xtimeradd | |
| 25 | + | |
| 26 | + | |
| 27 | +#define nil ((void*)0) | |
| 28 | + | |
| 29 | +typedef unsigned char p9_uchar; | |
| 30 | +typedef unsigned int p9_uint; | |
| 31 | +typedef unsigned int p9_ulong; | |
| 32 | +typedef int p9_long; | |
| 33 | +typedef signed char p9_schar; | |
| 34 | +typedef unsigned short p9_ushort; | |
| 35 | +typedef unsigned short Rune; | |
| 36 | +typedef unsigned int p9_u32int; | |
| 37 | +typedef p9_u32int mpdigit; | |
| 38 | + | |
| 39 | +/* make sure we don't conflict with predefined types */ | |
| 40 | +#define schar p9_schar | |
| 41 | +#define uchar p9_uchar | |
| 42 | +#define ushort p9_ushort | |
| 43 | +#define uint p9_uint | |
| 44 | +#define u32int p9_u32int | |
| 45 | + | |
| 46 | +/* #define long int rather than p9_long so that "unsigned long" is valid */ | |
| 47 | +#define long int | |
| 48 | +#define ulong p9_ulong | |
| 49 | +#define vlong p9_vlong | |
| 50 | +#define uvlong p9_uvlong | |
| 51 | + | |
| 52 | +#define nelem(x) (sizeof(x)/sizeof((x)[0])) | |
| 53 | +#define USED(x) if(x);else | |
| 54 | +#define SET(x) | |
| 55 | + | |
| 56 | +enum | |
| 57 | +{ | |
| 58 | + UTFmax = 3, /* maximum bytes per rune */ | |
| 59 | + Runesync = 0x80, /* cannot represent part of a UTF sequence (<) */ | |
| 60 | + Runeself = 0x80, /* rune and UTF sequences are the same (<) */ | |
| 61 | + Runeerror = 0x80 /* decoding error in UTF */ | |
| 62 | +}; | |
| 63 | + | |
| 64 | +/* | |
| 65 | + * new rune routines | |
| 66 | + */ | |
| 67 | +extern int runetochar(char*, Rune*); | |
| 68 | +extern int chartorune(Rune*, char*); | |
| 69 | +extern int runelen(long); | |
| 70 | +extern int fullrune(char*, int); | |
| 71 | + | |
| 72 | +extern int wstrtoutf(char*, Rune*, int); | |
| 73 | +extern int wstrutflen(Rune*); | |
| 74 | + | |
| 75 | +/* | |
| 76 | + * rune routines from converted str routines | |
| 77 | + */ | |
| 78 | +extern long utflen(char*); | |
| 79 | +extern char* utfrune(char*, long); | |
| 80 | +extern char* utfrrune(char*, long); | |
| 81 | + | |
| 82 | +/* | |
| 83 | + * Syscall data structures | |
| 84 | + */ | |
| 85 | +#define MORDER 0x0003 /* mask for bits defining order of mounting */ | |
| 86 | +#define MREPL 0x0000 /* mount replaces object */ | |
| 87 | +#define MBEFORE 0x0001 /* mount goes before others in union directory */ | |
| 88 | +#define MAFTER 0x0002 /* mount goes after others in union directory */ | |
| 89 | +#define MCREATE 0x0004 /* permit creation in mounted directory */ | |
| 90 | +#define MCACHE 0x0010 /* cache some data */ | |
| 91 | +#define MMASK 0x0017 /* all bits on */ | |
| 92 | + | |
| 93 | +#define OREAD 0 /* open for read */ | |
| 94 | +#define OWRITE 1 /* write */ | |
| 95 | +#define ORDWR 2 /* read and write */ | |
| 96 | +#define OEXEC 3 /* execute, == read but check execute permission */ | |
| 97 | +#define OTRUNC 16 /* or'ed in (except for exec), truncate file first */ | |
| 98 | +#define OCEXEC 32 /* or'ed in, close on exec */ | |
| 99 | +#define ORCLOSE 64 /* or'ed in, remove on close */ | |
| 100 | +#define OEXCL 0x1000 /* or'ed in, exclusive create */ | |
| 101 | + | |
| 102 | +#define NCONT 0 /* continue after note */ | |
| 103 | +#define NDFLT 1 /* terminate after note */ | |
| 104 | +#define NSAVE 2 /* clear note but hold state */ | |
| 105 | +#define NRSTR 3 /* restore saved state */ | |
| 106 | + | |
| 107 | +#define ERRMAX 128 /* max length of error string */ | |
| 108 | +#define KNAMELEN 28 /* max length of name held in kernel */ | |
| 109 | + | |
| 110 | +/* bits in Qid.type */ | |
| 111 | +#define QTDIR 0x80 /* type bit for directories */ | |
| 112 | +#define QTAPPEND 0x40 /* type bit for append only files */ | |
| 113 | +#define QTEXCL 0x20 /* type bit for exclusive use files */ | |
| 114 | +#define QTMOUNT 0x10 /* type bit for mounted channel */ | |
| 115 | +#define QTAUTH 0x08 /* type bit for authentication file */ | |
| 116 | +#define QTFILE 0x00 /* plain file */ | |
| 117 | + | |
| 118 | +/* bits in Dir.mode */ | |
| 119 | +#define DMDIR 0x80000000 /* mode bit for directories */ | |
| 120 | +#define DMAPPEND 0x40000000 /* mode bit for append only files */ | |
| 121 | +#define DMEXCL 0x20000000 /* mode bit for exclusive use files */ | |
| 122 | +#define DMMOUNT 0x10000000 /* mode bit for mounted channel */ | |
| 123 | +#define DMAUTH 0x08000000 /* mode bit for authentication files */ | |
| 124 | +#define DMREAD 0x4 /* mode bit for read permission */ | |
| 125 | +#define DMWRITE 0x2 /* mode bit for write permission */ | |
| 126 | +#define DMEXEC 0x1 /* mode bit for execute permission */ | |
| 127 | + | |
| 128 | +typedef struct Lock | |
| 129 | +{ | |
| 130 | + long key; | |
| 131 | +} Lock; | |
| 132 | + | |
| 133 | +typedef struct QLock | |
| 134 | +{ | |
| 135 | + Lock lk; | |
| 136 | + struct Proc *hold; | |
| 137 | + struct Proc *first; | |
| 138 | + struct Proc *last; | |
| 139 | +} QLock; | |
| 140 | + | |
| 141 | +typedef | |
| 142 | +struct Qid | |
| 143 | +{ | |
| 144 | + uvlong path; | |
| 145 | + ulong vers; | |
| 146 | + uchar type; | |
| 147 | +} Qid; | |
| 148 | + | |
| 149 | +typedef | |
| 150 | +struct Dir { | |
| 151 | + /* system-modified data */ | |
| 152 | + ushort type; /* server type */ | |
| 153 | + uint dev; /* server subtype */ | |
| 154 | + /* file data */ | |
| 155 | + Qid qid; /* unique id from server */ | |
| 156 | + ulong mode; /* permissions */ | |
| 157 | + ulong atime; /* last read time */ | |
| 158 | + ulong mtime; /* last write time */ | |
| 159 | + vlong length; /* file length */ | |
| 160 | + char *name; /* last element of path */ | |
| 161 | + char *uid; /* owner name */ | |
| 162 | + char *gid; /* group name */ | |
| 163 | + char *muid; /* last modifier name */ | |
| 164 | +} Dir; | |
| 165 | + | |
| 166 | +typedef | |
| 167 | +struct Waitmsg | |
| 168 | +{ | |
| 169 | + int pid; /* of loved one */ | |
| 170 | + ulong time[3]; /* of loved one & descendants */ | |
| 171 | + char *msg; | |
| 172 | +} Waitmsg; | |
| 173 | + | |
| 174 | +/* | |
| 175 | + * print routines | |
| 176 | + */ | |
| 177 | +typedef struct Fmt Fmt; | |
| 178 | +struct Fmt{ | |
| 179 | + uchar runes; /* output buffer is runes or chars? */ | |
| 180 | + void *start; /* of buffer */ | |
| 181 | + void *to; /* current place in the buffer */ | |
| 182 | + void *stop; /* end of the buffer; overwritten if flush fails */ | |
| 183 | + int (*flush)(Fmt *); /* called when to == stop */ | |
| 184 | + void *farg; /* to make flush a closure */ | |
| 185 | + int nfmt; /* num chars formatted so far */ | |
| 186 | + va_list args; /* args passed to dofmt */ | |
| 187 | + int r; /* % format Rune */ | |
| 188 | + int width; | |
| 189 | + int prec; | |
| 190 | + ulong flags; | |
| 191 | +}; | |
| 192 | + | |
| 193 | +enum{ | |
| 194 | + FmtWidth = 1, | |
| 195 | + FmtLeft = FmtWidth << 1, | |
| 196 | + FmtPrec = FmtLeft << 1, | |
| 197 | + FmtSharp = FmtPrec << 1, | |
| 198 | + FmtSpace = FmtSharp << 1, | |
| 199 | + FmtSign = FmtSpace << 1, | |
| 200 | + FmtZero = FmtSign << 1, | |
| 201 | + FmtUnsigned = FmtZero << 1, | |
| 202 | + FmtShort = FmtUnsigned << 1, | |
| 203 | + FmtLong = FmtShort << 1, | |
| 204 | + FmtVLong = FmtLong << 1, | |
| 205 | + FmtComma = FmtVLong << 1, | |
| 206 | + FmtByte = FmtComma << 1, | |
| 207 | + | |
| 208 | + FmtFlag = FmtByte << 1 | |
| 209 | +}; | |
| 210 | + | |
| 211 | +extern int print(char*, ...); | |
| 212 | +extern char* seprint(char*, char*, char*, ...); | |
| 213 | +extern char* vseprint(char*, char*, char*, va_list); | |
| 214 | +extern int snprint(char*, int, char*, ...); | |
| 215 | +extern int vsnprint(char*, int, char*, va_list); | |
| 216 | +extern char* smprint(char*, ...); | |
| 217 | +extern char* vsmprint(char*, va_list); | |
| 218 | +extern int sprint(char*, char*, ...); | |
| 219 | +extern int fprint(int, char*, ...); | |
| 220 | +extern int vfprint(int, char*, va_list); | |
| 221 | + | |
| 222 | +extern int (*doquote)(int); | |
| 223 | +extern int runesprint(Rune*, char*, ...); | |
| 224 | +extern int runesnprint(Rune*, int, char*, ...); | |
| 225 | +extern int runevsnprint(Rune*, int, char*, va_list); | |
| 226 | +extern Rune* runeseprint(Rune*, Rune*, char*, ...); | |
| 227 | +extern Rune* runevseprint(Rune*, Rune*, char*, va_list); | |
| 228 | +extern Rune* runesmprint(char*, ...); | |
| 229 | +extern Rune* runevsmprint(char*, va_list); | |
| 230 | + | |
| 231 | +extern int fmtfdinit(Fmt*, int, char*, int); | |
| 232 | +extern int fmtfdflush(Fmt*); | |
| 233 | +extern int fmtstrinit(Fmt*); | |
| 234 | +extern int fmtinstall(int, int (*)(Fmt*)); | |
| 235 | +extern char* fmtstrflush(Fmt*); | |
| 236 | +extern int runefmtstrinit(Fmt*); | |
| 237 | +extern Rune* runefmtstrflush(Fmt*); | |
| 238 | + | |
| 239 | +extern void* mallocz(ulong, int); | |
| 240 | + | |
| 241 | +extern void srand(long); | |
| 242 | +extern int rand(void); | |
| 243 | +extern int nrand(int); | |
| 244 | +extern long lrand(void); | |
| 245 | +extern long lnrand(long); | |
| 246 | +extern double frand(void); | |
| @@ -0,0 +1,3 @@ | ||
| 1 | +#include "lib.h" | |
| 2 | +#include "user.h" | |
| 3 | + | |
| @@ -0,0 +1,340 @@ | ||
| 1 | + | |
| 2 | +#ifndef _MPINT | |
| 3 | +typedef struct mpint mpint; | |
| 4 | +#endif | |
| 5 | + | |
| 6 | +///////////////////////////////////////////////////////// | |
| 7 | +// AES definitions | |
| 8 | +///////////////////////////////////////////////////////// | |
| 9 | + | |
| 10 | +enum | |
| 11 | +{ | |
| 12 | + AESbsize= 16, | |
| 13 | + AESmaxkey= 32, | |
| 14 | + AESmaxrounds= 14 | |
| 15 | +}; | |
| 16 | + | |
| 17 | +typedef struct AESstate AESstate; | |
| 18 | +struct AESstate | |
| 19 | +{ | |
| 20 | + ulong setup; | |
| 21 | + int rounds; | |
| 22 | + int keybytes; | |
| 23 | + uchar key[AESmaxkey]; /* unexpanded key */ | |
| 24 | + u32int ekey[4*(AESmaxrounds + 1)]; /* encryption key */ | |
| 25 | + u32int dkey[4*(AESmaxrounds + 1)]; /* decryption key */ | |
| 26 | + uchar ivec[AESbsize]; /* initialization vector */ | |
| 27 | +}; | |
| 28 | + | |
| 29 | +void setupAESstate(AESstate *s, uchar key[], int keybytes, uchar *ivec); | |
| 30 | +void aesCBCencrypt(uchar *p, int len, AESstate *s); | |
| 31 | +void aesCBCdecrypt(uchar *p, int len, AESstate *s); | |
| 32 | + | |
| 33 | +///////////////////////////////////////////////////////// | |
| 34 | +// Blowfish Definitions | |
| 35 | +///////////////////////////////////////////////////////// | |
| 36 | + | |
| 37 | +enum | |
| 38 | +{ | |
| 39 | + BFbsize = 8, | |
| 40 | + BFrounds = 16 | |
| 41 | +}; | |
| 42 | + | |
| 43 | +// 16-round Blowfish | |
| 44 | +typedef struct BFstate BFstate; | |
| 45 | +struct BFstate | |
| 46 | +{ | |
| 47 | + ulong setup; | |
| 48 | + | |
| 49 | + uchar key[56]; | |
| 50 | + uchar ivec[8]; | |
| 51 | + | |
| 52 | + u32int pbox[BFrounds+2]; | |
| 53 | + u32int sbox[1024]; | |
| 54 | +}; | |
| 55 | + | |
| 56 | +void setupBFstate(BFstate *s, uchar key[], int keybytes, uchar *ivec); | |
| 57 | +void bfCBCencrypt(uchar*, int, BFstate*); | |
| 58 | +void bfCBCdecrypt(uchar*, int, BFstate*); | |
| 59 | +void bfECBencrypt(uchar*, int, BFstate*); | |
| 60 | +void bfECBdecrypt(uchar*, int, BFstate*); | |
| 61 | + | |
| 62 | +///////////////////////////////////////////////////////// | |
| 63 | +// DES definitions | |
| 64 | +///////////////////////////////////////////////////////// | |
| 65 | + | |
| 66 | +enum | |
| 67 | +{ | |
| 68 | + DESbsize= 8 | |
| 69 | +}; | |
| 70 | + | |
| 71 | +// single des | |
| 72 | +typedef struct DESstate DESstate; | |
| 73 | +struct DESstate | |
| 74 | +{ | |
| 75 | + ulong setup; | |
| 76 | + uchar key[8]; /* unexpanded key */ | |
| 77 | + ulong expanded[32]; /* expanded key */ | |
| 78 | + uchar ivec[8]; /* initialization vector */ | |
| 79 | +}; | |
| 80 | + | |
| 81 | +void setupDESstate(DESstate *s, uchar key[8], uchar *ivec); | |
| 82 | +void des_key_setup(uchar[8], ulong[32]); | |
| 83 | +void block_cipher(ulong*, uchar*, int); | |
| 84 | +void desCBCencrypt(uchar*, int, DESstate*); | |
| 85 | +void desCBCdecrypt(uchar*, int, DESstate*); | |
| 86 | +void desECBencrypt(uchar*, int, DESstate*); | |
| 87 | +void desECBdecrypt(uchar*, int, DESstate*); | |
| 88 | + | |
| 89 | +// for backward compatibility with 7 byte DES key format | |
| 90 | +void des56to64(uchar *k56, uchar *k64); | |
| 91 | +void des64to56(uchar *k64, uchar *k56); | |
| 92 | +void key_setup(uchar[7], ulong[32]); | |
| 93 | + | |
| 94 | +// triple des encrypt/decrypt orderings | |
| 95 | +enum { | |
| 96 | + DES3E= 0, | |
| 97 | + DES3D= 1, | |
| 98 | + DES3EEE= 0, | |
| 99 | + DES3EDE= 2, | |
| 100 | + DES3DED= 5, | |
| 101 | + DES3DDD= 7 | |
| 102 | +}; | |
| 103 | + | |
| 104 | +typedef struct DES3state DES3state; | |
| 105 | +struct DES3state | |
| 106 | +{ | |
| 107 | + ulong setup; | |
| 108 | + uchar key[3][8]; /* unexpanded key */ | |
| 109 | + ulong expanded[3][32]; /* expanded key */ | |
| 110 | + uchar ivec[8]; /* initialization vector */ | |
| 111 | +}; | |
| 112 | + | |
| 113 | +void setupDES3state(DES3state *s, uchar key[3][8], uchar *ivec); | |
| 114 | +void triple_block_cipher(ulong keys[3][32], uchar*, int); | |
| 115 | +void des3CBCencrypt(uchar*, int, DES3state*); | |
| 116 | +void des3CBCdecrypt(uchar*, int, DES3state*); | |
| 117 | +void des3ECBencrypt(uchar*, int, DES3state*); | |
| 118 | +void des3ECBdecrypt(uchar*, int, DES3state*); | |
| 119 | + | |
| 120 | +///////////////////////////////////////////////////////// | |
| 121 | +// digests | |
| 122 | +///////////////////////////////////////////////////////// | |
| 123 | + | |
| 124 | +enum | |
| 125 | +{ | |
| 126 | + SHA1dlen= 20, /* SHA digest length */ | |
| 127 | + MD4dlen= 16, /* MD4 digest length */ | |
| 128 | + MD5dlen= 16 /* MD5 digest length */ | |
| 129 | +}; | |
| 130 | + | |
| 131 | +typedef struct DigestState DigestState; | |
| 132 | +struct DigestState | |
| 133 | +{ | |
| 134 | + ulong len; | |
| 135 | + u32int state[5]; | |
| 136 | + uchar buf[128]; | |
| 137 | + int blen; | |
| 138 | + char malloced; | |
| 139 | + char seeded; | |
| 140 | +}; | |
| 141 | +typedef struct DigestState SHAstate; /* obsolete name */ | |
| 142 | +typedef struct DigestState SHA1state; | |
| 143 | +typedef struct DigestState MD5state; | |
| 144 | +typedef struct DigestState MD4state; | |
| 145 | + | |
| 146 | +DigestState* md4(uchar*, ulong, uchar*, DigestState*); | |
| 147 | +DigestState* md5(uchar*, ulong, uchar*, DigestState*); | |
| 148 | +DigestState* sha1(uchar*, ulong, uchar*, DigestState*); | |
| 149 | +DigestState* hmac_md5(uchar*, ulong, uchar*, ulong, uchar*, DigestState*); | |
| 150 | +DigestState* hmac_sha1(uchar*, ulong, uchar*, ulong, uchar*, DigestState*); | |
| 151 | +char* sha1pickle(SHA1state*); | |
| 152 | +SHA1state* sha1unpickle(char*); | |
| 153 | + | |
| 154 | +///////////////////////////////////////////////////////// | |
| 155 | +// random number generation | |
| 156 | +///////////////////////////////////////////////////////// | |
| 157 | +void genrandom(uchar *buf, int nbytes); | |
| 158 | +void prng(uchar *buf, int nbytes); | |
| 159 | +ulong fastrand(void); | |
| 160 | +ulong nfastrand(ulong); | |
| 161 | + | |
| 162 | +///////////////////////////////////////////////////////// | |
| 163 | +// primes | |
| 164 | +///////////////////////////////////////////////////////// | |
| 165 | +void genprime(mpint *p, int n, int accuracy); // generate an n bit probable prime | |
| 166 | +void gensafeprime(mpint *p, mpint *alpha, int n, int accuracy); // prime and generator | |
| 167 | +void genstrongprime(mpint *p, int n, int accuracy); // generate an n bit strong prime | |
| 168 | +void DSAprimes(mpint *q, mpint *p, uchar seed[SHA1dlen]); | |
| 169 | +int probably_prime(mpint *n, int nrep); // miller-rabin test | |
| 170 | +int smallprimetest(mpint *p); // returns -1 if not prime, 0 otherwise | |
| 171 | + | |
| 172 | +///////////////////////////////////////////////////////// | |
| 173 | +// rc4 | |
| 174 | +///////////////////////////////////////////////////////// | |
| 175 | +typedef struct RC4state RC4state; | |
| 176 | +struct RC4state | |
| 177 | +{ | |
| 178 | + uchar state[256]; | |
| 179 | + uchar x; | |
| 180 | + uchar y; | |
| 181 | +}; | |
| 182 | + | |
| 183 | +void setupRC4state(RC4state*, uchar*, int); | |
| 184 | +void rc4(RC4state*, uchar*, int); | |
| 185 | +void rc4skip(RC4state*, int); | |
| 186 | +void rc4back(RC4state*, int); | |
| 187 | + | |
| 188 | +///////////////////////////////////////////////////////// | |
| 189 | +// rsa | |
| 190 | +///////////////////////////////////////////////////////// | |
| 191 | +typedef struct RSApub RSApub; | |
| 192 | +typedef struct RSApriv RSApriv; | |
| 193 | + | |
| 194 | +// public/encryption key | |
| 195 | +struct RSApub | |
| 196 | +{ | |
| 197 | + mpint *n; // modulus | |
| 198 | + mpint *ek; // exp (encryption key) | |
| 199 | +}; | |
| 200 | + | |
| 201 | +// private/decryption key | |
| 202 | +struct RSApriv | |
| 203 | +{ | |
| 204 | + RSApub pub; | |
| 205 | + | |
| 206 | + mpint *dk; // exp (decryption key) | |
| 207 | + | |
| 208 | + // precomputed values to help with chinese remainder theorem calc | |
| 209 | + mpint *p; | |
| 210 | + mpint *q; | |
| 211 | + mpint *kp; // dk mod p-1 | |
| 212 | + mpint *kq; // dk mod q-1 | |
| 213 | + mpint *c2; // (inv p) mod q | |
| 214 | +}; | |
| 215 | + | |
| 216 | +RSApriv* rsagen(int nlen, int elen, int rounds); | |
| 217 | +RSApriv* rsafill(mpint *n, mpint *e, mpint *d, mpint *p, mpint *q); | |
| 218 | +mpint* rsaencrypt(RSApub *k, mpint *in, mpint *out); | |
| 219 | +mpint* rsadecrypt(RSApriv *k, mpint *in, mpint *out); | |
| 220 | +RSApub* rsapuballoc(void); | |
| 221 | +void rsapubfree(RSApub*); | |
| 222 | +RSApriv* rsaprivalloc(void); | |
| 223 | +void rsaprivfree(RSApriv*); | |
| 224 | +RSApub* rsaprivtopub(RSApriv*); | |
| 225 | +RSApub* X509toRSApub(uchar*, int, char*, int); | |
| 226 | +RSApriv* asn1toRSApriv(uchar*, int); | |
| 227 | +void asn1dump(uchar *der, int len); | |
| 228 | +uchar* decodepem(char *s, char *type, int *len); | |
| 229 | +uchar* X509gen(RSApriv *priv, char *subj, ulong valid[2], int *certlen); | |
| 230 | +uchar* X509req(RSApriv *priv, char *subj, int *certlen); | |
| 231 | +char* X509verify(uchar *cert, int ncert, RSApub *pk); | |
| 232 | +void X509dump(uchar *cert, int ncert); | |
| 233 | +///////////////////////////////////////////////////////// | |
| 234 | +// elgamal | |
| 235 | +///////////////////////////////////////////////////////// | |
| 236 | +typedef struct EGpub EGpub; | |
| 237 | +typedef struct EGpriv EGpriv; | |
| 238 | +typedef struct EGsig EGsig; | |
| 239 | + | |
| 240 | +// public/encryption key | |
| 241 | +struct EGpub | |
| 242 | +{ | |
| 243 | + mpint *p; // modulus | |
| 244 | + mpint *alpha; // generator | |
| 245 | + mpint *key; // (encryption key) alpha**secret mod p | |
| 246 | +}; | |
| 247 | + | |
| 248 | +// private/decryption key | |
| 249 | +struct EGpriv | |
| 250 | +{ | |
| 251 | + EGpub pub; | |
| 252 | + mpint *secret; // (decryption key) | |
| 253 | +}; | |
| 254 | + | |
| 255 | +// signature | |
| 256 | +struct EGsig | |
| 257 | +{ | |
| 258 | + mpint *r, *s; | |
| 259 | +}; | |
| 260 | + | |
| 261 | +EGpriv* eggen(int nlen, int rounds); | |
| 262 | +mpint* egencrypt(EGpub *k, mpint *in, mpint *out); | |
| 263 | +mpint* egdecrypt(EGpriv *k, mpint *in, mpint *out); | |
| 264 | +EGsig* egsign(EGpriv *k, mpint *m); | |
| 265 | +int egverify(EGpub *k, EGsig *sig, mpint *m); | |
| 266 | +EGpub* egpuballoc(void); | |
| 267 | +void egpubfree(EGpub*); | |
| 268 | +EGpriv* egprivalloc(void); | |
| 269 | +void egprivfree(EGpriv*); | |
| 270 | +EGsig* egsigalloc(void); | |
| 271 | +void egsigfree(EGsig*); | |
| 272 | +EGpub* egprivtopub(EGpriv*); | |
| 273 | + | |
| 274 | +///////////////////////////////////////////////////////// | |
| 275 | +// dsa | |
| 276 | +///////////////////////////////////////////////////////// | |
| 277 | +typedef struct DSApub DSApub; | |
| 278 | +typedef struct DSApriv DSApriv; | |
| 279 | +typedef struct DSAsig DSAsig; | |
| 280 | + | |
| 281 | +// public/encryption key | |
| 282 | +struct DSApub | |
| 283 | +{ | |
| 284 | + mpint *p; // modulus | |
| 285 | + mpint *q; // group order, q divides p-1 | |
| 286 | + mpint *alpha; // group generator | |
| 287 | + mpint *key; // (encryption key) alpha**secret mod p | |
| 288 | +}; | |
| 289 | + | |
| 290 | +// private/decryption key | |
| 291 | +struct DSApriv | |
| 292 | +{ | |
| 293 | + DSApub pub; | |
| 294 | + mpint *secret; // (decryption key) | |
| 295 | +}; | |
| 296 | + | |
| 297 | +// signature | |
| 298 | +struct DSAsig | |
| 299 | +{ | |
| 300 | + mpint *r, *s; | |
| 301 | +}; | |
| 302 | + | |
| 303 | +DSApriv* dsagen(DSApub *opub); | |
| 304 | +DSAsig* dsasign(DSApriv *k, mpint *m); | |
| 305 | +int dsaverify(DSApub *k, DSAsig *sig, mpint *m); | |
| 306 | +DSApub* dsapuballoc(void); | |
| 307 | +void dsapubfree(DSApub*); | |
| 308 | +DSApriv* dsaprivalloc(void); | |
| 309 | +void dsaprivfree(DSApriv*); | |
| 310 | +DSAsig* dsasigalloc(void); | |
| 311 | +void dsasigfree(DSAsig*); | |
| 312 | +DSApub* dsaprivtopub(DSApriv*); | |
| 313 | + | |
| 314 | +///////////////////////////////////////////////////////// | |
| 315 | +// TLS | |
| 316 | +///////////////////////////////////////////////////////// | |
| 317 | +typedef struct Thumbprint{ | |
| 318 | + struct Thumbprint *next; | |
| 319 | + uchar sha1[SHA1dlen]; | |
| 320 | +} Thumbprint; | |
| 321 | + | |
| 322 | +typedef struct TLSconn{ | |
| 323 | + char dir[40]; // connection directory | |
| 324 | + uchar *cert; // certificate (local on input, remote on output) | |
| 325 | + uchar *sessionID; | |
| 326 | + int certlen, sessionIDlen; | |
| 327 | + int (*trace)(char*fmt, ...); | |
| 328 | +} TLSconn; | |
| 329 | + | |
| 330 | +// tlshand.c | |
| 331 | +extern int tlsClient(int fd, TLSconn *c); | |
| 332 | +extern int tlsServer(int fd, TLSconn *c); | |
| 333 | + | |
| 334 | +// thumb.c | |
| 335 | +extern Thumbprint* initThumbprints(char *ok, char *crl); | |
| 336 | +extern void freeThumbprints(Thumbprint *ok); | |
| 337 | +extern int okThumbprint(uchar *sha1, Thumbprint *ok); | |
| 338 | + | |
| 339 | +// readcert.c | |
| 340 | +extern uchar *readcert(char *filename, int *pcertlen); | |
| @@ -0,0 +1,200 @@ | ||
| 1 | +#pragma src "/sys/src/libmemdraw" | |
| 2 | +#pragma lib "libmemdraw.a" | |
| 3 | + | |
| 4 | +typedef struct Memimage Memimage; | |
| 5 | +typedef struct Memdata Memdata; | |
| 6 | +typedef struct Memsubfont Memsubfont; | |
| 7 | +typedef struct Memlayer Memlayer; | |
| 8 | +typedef struct Memcmap Memcmap; | |
| 9 | +typedef struct Memdrawparam Memdrawparam; | |
| 10 | + | |
| 11 | +/* | |
| 12 | + * Memdata is allocated from main pool, but .data from the image pool. | |
| 13 | + * Memdata is allocated separately to permit patching its pointer after | |
| 14 | + * compaction when windows share the image data. | |
| 15 | + * The first word of data is a back pointer to the Memdata, to find | |
| 16 | + * The word to patch. | |
| 17 | + */ | |
| 18 | + | |
| 19 | +struct Memdata | |
| 20 | +{ | |
| 21 | + ulong *base; /* allocated data pointer */ | |
| 22 | + uchar *bdata; /* pointer to first byte of actual data; word-aligned */ | |
| 23 | + int ref; /* number of Memimages using this data */ | |
| 24 | + void* imref; | |
| 25 | + int allocd; /* is this malloc'd? */ | |
| 26 | +}; | |
| 27 | + | |
| 28 | +enum { | |
| 29 | + Frepl = 1<<0, /* is replicated */ | |
| 30 | + Fsimple = 1<<1, /* is 1x1 */ | |
| 31 | + Fgrey = 1<<2, /* is grey */ | |
| 32 | + Falpha = 1<<3, /* has explicit alpha */ | |
| 33 | + Fcmap = 1<<4, /* has cmap channel */ | |
| 34 | + Fbytes = 1<<5, /* has only 8-bit channels */ | |
| 35 | +}; | |
| 36 | + | |
| 37 | +struct Memimage | |
| 38 | +{ | |
| 39 | + Rectangle r; /* rectangle in data area, local coords */ | |
| 40 | + Rectangle clipr; /* clipping region */ | |
| 41 | + int depth; /* number of bits of storage per pixel */ | |
| 42 | + int nchan; /* number of channels */ | |
| 43 | + ulong chan; /* channel descriptions */ | |
| 44 | + Memcmap *cmap; | |
| 45 | + | |
| 46 | + Memdata *data; /* pointer to data; shared by windows in this image */ | |
| 47 | + int zero; /* data->bdata+zero==&byte containing (0,0) */ | |
| 48 | + ulong width; /* width in words of a single scan line */ | |
| 49 | + Memlayer *layer; /* nil if not a layer*/ | |
| 50 | + ulong flags; | |
| 51 | + | |
| 52 | + int shift[NChan]; | |
| 53 | + int mask[NChan]; | |
| 54 | + int nbits[NChan]; | |
| 55 | + | |
| 56 | + void *X; | |
| 57 | +}; | |
| 58 | + | |
| 59 | +struct Memcmap | |
| 60 | +{ | |
| 61 | + uchar cmap2rgb[3*256]; | |
| 62 | + uchar rgb2cmap[16*16*16]; | |
| 63 | +}; | |
| 64 | + | |
| 65 | +/* | |
| 66 | + * Subfonts | |
| 67 | + * | |
| 68 | + * given char c, Subfont *f, Fontchar *i, and Point p, one says | |
| 69 | + * i = f->info+c; | |
| 70 | + * draw(b, Rect(p.x+i->left, p.y+i->top, | |
| 71 | + * p.x+i->left+((i+1)->x-i->x), p.y+i->bottom), | |
| 72 | + * color, f->bits, Pt(i->x, i->top)); | |
| 73 | + * p.x += i->width; | |
| 74 | + * to draw characters in the specified color (itself a Memimage) in Memimage b. | |
| 75 | + */ | |
| 76 | + | |
| 77 | +struct Memsubfont | |
| 78 | +{ | |
| 79 | + char *name; | |
| 80 | + short n; /* number of chars in font */ | |
| 81 | + uchar height; /* height of bitmap */ | |
| 82 | + char ascent; /* top of bitmap to baseline */ | |
| 83 | + Fontchar *info; /* n+1 character descriptors */ | |
| 84 | + Memimage *bits; /* of font */ | |
| 85 | +}; | |
| 86 | + | |
| 87 | +/* | |
| 88 | + * Encapsulated parameters and information for sub-draw routines. | |
| 89 | + */ | |
| 90 | +enum { | |
| 91 | + Simplesrc=1<<0, | |
| 92 | + Simplemask=1<<1, | |
| 93 | + Replsrc=1<<2, | |
| 94 | + Replmask=1<<3, | |
| 95 | + Fullmask=1<<4, | |
| 96 | +}; | |
| 97 | +struct Memdrawparam | |
| 98 | +{ | |
| 99 | + Memimage *dst; | |
| 100 | + Rectangle r; | |
| 101 | + Memimage *src; | |
| 102 | + Rectangle sr; | |
| 103 | + Memimage *mask; | |
| 104 | + Rectangle mr; | |
| 105 | + int op; | |
| 106 | + | |
| 107 | + ulong state; | |
| 108 | + ulong mval; /* if Simplemask, the mask pixel in mask format */ | |
| 109 | + ulong mrgba; /* mval in rgba */ | |
| 110 | + ulong sval; /* if Simplesrc, the source pixel in src format */ | |
| 111 | + ulong srgba; /* sval in rgba */ | |
| 112 | + ulong sdval; /* sval in dst format */ | |
| 113 | +}; | |
| 114 | + | |
| 115 | +/* | |
| 116 | + * Memimage management | |
| 117 | + */ | |
| 118 | + | |
| 119 | +extern Memimage* allocmemimage(Rectangle, ulong); | |
| 120 | +extern Memimage* _allocmemimage(Rectangle, ulong); | |
| 121 | +extern Memimage* allocmemimaged(Rectangle, ulong, Memdata*, void*); | |
| 122 | +extern Memimage* readmemimage(int); | |
| 123 | +extern Memimage* creadmemimage(int); | |
| 124 | +extern int writememimage(int, Memimage*); | |
| 125 | +extern void freememimage(Memimage*); | |
| 126 | +extern int _loadmemimage(Memimage*, Rectangle, uchar*, int); | |
| 127 | +extern int _cloadmemimage(Memimage*, Rectangle, uchar*, int); | |
| 128 | +extern int _unloadmemimage(Memimage*, Rectangle, uchar*, int); | |
| 129 | +extern int loadmemimage(Memimage*, Rectangle, uchar*, int); | |
| 130 | +extern int cloadmemimage(Memimage*, Rectangle, uchar*, int); | |
| 131 | +extern int unloadmemimage(Memimage*, Rectangle, uchar*, int); | |
| 132 | +extern ulong* wordaddr(Memimage*, Point); | |
| 133 | +extern uchar* byteaddr(Memimage*, Point); | |
| 134 | +extern int drawclip(Memimage*, Rectangle*, Memimage*, Point*, Memimage*, Point*, Rectangle*, Rectangle*); | |
| 135 | +extern void memfillcolor(Memimage*, ulong); | |
| 136 | +extern int memsetchan(Memimage*, ulong); | |
| 137 | + | |
| 138 | +/* | |
| 139 | + * Graphics | |
| 140 | + */ | |
| 141 | +extern void memdraw(Memimage*, Rectangle, Memimage*, Point, Memimage*, Point, int); | |
| 142 | +extern void memline(Memimage*, Point, Point, int, int, int, Memimage*, Point, int); | |
| 143 | +extern void mempoly(Memimage*, Point*, int, int, int, int, Memimage*, Point, int); | |
| 144 | +extern void memfillpoly(Memimage*, Point*, int, int, Memimage*, Point, int); | |
| 145 | +extern void _memfillpolysc(Memimage*, Point*, int, int, Memimage*, Point, int, int, int, int); | |
| 146 | +extern Memdrawparam* _memimagedrawsetup(Memimage*, Rectangle, Memimage*, Point, Memimage*, Point, int); | |
| 147 | +extern void _memimagedraw(Memdrawparam*); | |
| 148 | +extern void memimagedraw(Memimage*, Rectangle, Memimage*, Point, Memimage*, Point, int); | |
| 149 | +extern int hwdraw(Memdrawparam*); | |
| 150 | +extern void memimageline(Memimage*, Point, Point, int, int, int, Memimage*, Point, int); | |
| 151 | +extern void _memimageline(Memimage*, Point, Point, int, int, int, Memimage*, Point, Rectangle, int); | |
| 152 | +extern Point memimagestring(Memimage*, Point, Memimage*, Point, Memsubfont*, char*); | |
| 153 | +extern void memellipse(Memimage*, Point, int, int, int, Memimage*, Point, int); | |
| 154 | +extern void memarc(Memimage*, Point, int, int, int, Memimage*, Point, int, int, int); | |
| 155 | +extern Rectangle memlinebbox(Point, Point, int, int, int); | |
| 156 | +extern int memlineendsize(int); | |
| 157 | +extern void _memmkcmap(void); | |
| 158 | +extern void memimageinit(void); | |
| 159 | + | |
| 160 | +/* | |
| 161 | + * Subfont management | |
| 162 | + */ | |
| 163 | +extern Memsubfont* allocmemsubfont(char*, int, int, int, Fontchar*, Memimage*); | |
| 164 | +extern Memsubfont* openmemsubfont(char*); | |
| 165 | +extern void freememsubfont(Memsubfont*); | |
| 166 | +extern Point memsubfontwidth(Memsubfont*, char*); | |
| 167 | +extern Memsubfont* getmemdefont(void); | |
| 168 | + | |
| 169 | +/* | |
| 170 | + * Predefined | |
| 171 | + */ | |
| 172 | +extern Memimage* memwhite; | |
| 173 | +extern Memimage* memblack; | |
| 174 | +extern Memimage* memopaque; | |
| 175 | +extern Memimage* memtransparent; | |
| 176 | +extern Memcmap *memdefcmap; | |
| 177 | + | |
| 178 | +/* | |
| 179 | + * Kernel interface | |
| 180 | + */ | |
| 181 | +void memimagemove(void*, void*); | |
| 182 | + | |
| 183 | +/* | |
| 184 | + * Kernel cruft | |
| 185 | + */ | |
| 186 | +extern void rdb(void); | |
| 187 | +extern int iprint(char*, ...); | |
| 188 | +#pragma varargck argpos iprint 1 | |
| 189 | +extern int drawdebug; | |
| 190 | + | |
| 191 | +/* | |
| 192 | + * doprint interface: numbconv bit strings | |
| 193 | + */ | |
| 194 | +#pragma varargck type "llb" vlong | |
| 195 | +#pragma varargck type "llb" uvlong | |
| 196 | +#pragma varargck type "lb" long | |
| 197 | +#pragma varargck type "lb" ulong | |
| 198 | +#pragma varargck type "b" int | |
| 199 | +#pragma varargck type "b" uint | |
| 200 | + | |
| @@ -0,0 +1,51 @@ | ||
| 1 | +#pragma src "/sys/src/libmemlayer" | |
| 2 | +#pragma lib "libmemlayer.a" | |
| 3 | + | |
| 4 | +typedef struct Memscreen Memscreen; | |
| 5 | +typedef void (*Refreshfn)(Memimage*, Rectangle, void*); | |
| 6 | + | |
| 7 | +struct Memscreen | |
| 8 | +{ | |
| 9 | + Memimage *frontmost; /* frontmost layer on screen */ | |
| 10 | + Memimage *rearmost; /* rearmost layer on screen */ | |
| 11 | + Memimage *image; /* upon which all layers are drawn */ | |
| 12 | + Memimage *fill; /* if non-zero, picture to use when repainting */ | |
| 13 | +}; | |
| 14 | + | |
| 15 | +struct Memlayer | |
| 16 | +{ | |
| 17 | + Rectangle screenr; /* true position of layer on screen */ | |
| 18 | + Point delta; /* add delta to go from image coords to screen */ | |
| 19 | + Memscreen *screen; /* screen this layer belongs to */ | |
| 20 | + Memimage *front; /* window in front of this one */ | |
| 21 | + Memimage *rear; /* window behind this one*/ | |
| 22 | + int clear; /* layer is fully visible */ | |
| 23 | + Memimage *save; /* save area for obscured parts */ | |
| 24 | + Refreshfn refreshfn; /* function to call to refresh obscured parts if save==nil */ | |
| 25 | + void *refreshptr; /* argument to refreshfn */ | |
| 26 | +}; | |
| 27 | + | |
| 28 | +/* | |
| 29 | + * These functions accept local coordinates | |
| 30 | + */ | |
| 31 | +int memload(Memimage*, Rectangle, uchar*, int, int); | |
| 32 | +int memunload(Memimage*, Rectangle, uchar*, int); | |
| 33 | + | |
| 34 | +/* | |
| 35 | + * All these functions accept screen coordinates, not local ones. | |
| 36 | + */ | |
| 37 | +void _memlayerop(void (*fn)(Memimage*, Rectangle, Rectangle, void*, int), Memimage*, Rectangle, Rectangle, void*); | |
| 38 | +Memimage* memlalloc(Memscreen*, Rectangle, Refreshfn, void*, ulong); | |
| 39 | +void memldelete(Memimage*); | |
| 40 | +void memlfree(Memimage*); | |
| 41 | +void memltofront(Memimage*); | |
| 42 | +void memltofrontn(Memimage**, int); | |
| 43 | +void _memltofrontfill(Memimage*, int); | |
| 44 | +void memltorear(Memimage*); | |
| 45 | +void memltorearn(Memimage**, int); | |
| 46 | +int memlsetrefresh(Memimage*, Refreshfn, void*); | |
| 47 | +void memlhide(Memimage*, Rectangle); | |
| 48 | +void memlexpose(Memimage*, Rectangle); | |
| 49 | +void _memlsetclear(Memscreen*); | |
| 50 | +int memlorigin(Memimage*, Point, Point); | |
| 51 | +void memlnorefresh(Memimage*, Rectangle, void*); | |
| @@ -0,0 +1,134 @@ | ||
| 1 | +#define _MPINT 1 | |
| 2 | + | |
| 3 | +// the code assumes mpdigit to be at least an int | |
| 4 | +// mpdigit must be an atomic type. mpdigit is defined | |
| 5 | +// in the architecture specific u.h | |
| 6 | + | |
| 7 | +typedef struct mpint mpint; | |
| 8 | + | |
| 9 | +struct mpint | |
| 10 | +{ | |
| 11 | + int sign; // +1 or -1 | |
| 12 | + int size; // allocated digits | |
| 13 | + int top; // significant digits | |
| 14 | + mpdigit *p; | |
| 15 | + char flags; | |
| 16 | +}; | |
| 17 | + | |
| 18 | +enum | |
| 19 | +{ | |
| 20 | + MPstatic= 0x01, | |
| 21 | + Dbytes= sizeof(mpdigit), // bytes per digit | |
| 22 | + Dbits= Dbytes*8 // bits per digit | |
| 23 | +}; | |
| 24 | + | |
| 25 | +// allocation | |
| 26 | +void mpsetminbits(int n); // newly created mpint's get at least n bits | |
| 27 | +mpint* mpnew(int n); // create a new mpint with at least n bits | |
| 28 | +void mpfree(mpint *b); | |
| 29 | +void mpbits(mpint *b, int n); // ensure that b has at least n bits | |
| 30 | +void mpnorm(mpint *b); // dump leading zeros | |
| 31 | +mpint* mpcopy(mpint *b); | |
| 32 | +void mpassign(mpint *old, mpint *new); | |
| 33 | + | |
| 34 | +// random bits | |
| 35 | +mpint* mprand(int bits, void (*gen)(uchar*, int), mpint *b); | |
| 36 | + | |
| 37 | +// conversion | |
| 38 | +mpint* strtomp(char*, char**, int, mpint*); // ascii | |
| 39 | +int mpfmt(Fmt*); | |
| 40 | +char* mptoa(mpint*, int, char*, int); | |
| 41 | +mpint* letomp(uchar*, uint, mpint*); // byte array, little-endian | |
| 42 | +int mptole(mpint*, uchar*, uint, uchar**); | |
| 43 | +mpint* betomp(uchar*, uint, mpint*); // byte array, little-endian | |
| 44 | +int mptobe(mpint*, uchar*, uint, uchar**); | |
| 45 | +uint mptoui(mpint*); // unsigned int | |
| 46 | +mpint* uitomp(uint, mpint*); | |
| 47 | +int mptoi(mpint*); // int | |
| 48 | +mpint* itomp(int, mpint*); | |
| 49 | +uvlong mptouv(mpint*); // unsigned vlong | |
| 50 | +mpint* uvtomp(uvlong, mpint*); | |
| 51 | +vlong mptov(mpint*); // vlong | |
| 52 | +mpint* vtomp(vlong, mpint*); | |
| 53 | + | |
| 54 | +// divide 2 digits by one | |
| 55 | +void mpdigdiv(mpdigit *dividend, mpdigit divisor, mpdigit *quotient); | |
| 56 | + | |
| 57 | +// in the following, the result mpint may be | |
| 58 | +// the same as one of the inputs. | |
| 59 | +void mpadd(mpint *b1, mpint *b2, mpint *sum); // sum = b1+b2 | |
| 60 | +void mpsub(mpint *b1, mpint *b2, mpint *diff); // diff = b1-b2 | |
| 61 | +void mpleft(mpint *b, int shift, mpint *res); // res = b<<shift | |
| 62 | +void mpright(mpint *b, int shift, mpint *res); // res = b>>shift | |
| 63 | +void mpmul(mpint *b1, mpint *b2, mpint *prod); // prod = b1*b2 | |
| 64 | +void mpexp(mpint *b, mpint *e, mpint *m, mpint *res); // res = b**e mod m | |
| 65 | +void mpmod(mpint *b, mpint *m, mpint *remainder); // remainder = b mod m | |
| 66 | + | |
| 67 | +// quotient = dividend/divisor, remainder = dividend % divisor | |
| 68 | +void mpdiv(mpint *dividend, mpint *divisor, mpint *quotient, mpint *remainder); | |
| 69 | + | |
| 70 | +// return neg, 0, pos as b1-b2 is neg, 0, pos | |
| 71 | +int mpcmp(mpint *b1, mpint *b2); | |
| 72 | + | |
| 73 | +// extended gcd return d, x, and y, s.t. d = gcd(a,b) and ax+by = d | |
| 74 | +void mpextendedgcd(mpint *a, mpint *b, mpint *d, mpint *x, mpint *y); | |
| 75 | + | |
| 76 | +// res = b**-1 mod m | |
| 77 | +void mpinvert(mpint *b, mpint *m, mpint *res); | |
| 78 | + | |
| 79 | +// bit counting | |
| 80 | +int mpsignif(mpint*); // number of sigificant bits in mantissa | |
| 81 | +int mplowbits0(mpint*); // k, where n = 2**k * q for odd q | |
| 82 | + | |
| 83 | +// well known constants | |
| 84 | +extern mpint *mpzero, *mpone, *mptwo; | |
| 85 | + | |
| 86 | +// sum[0:alen] = a[0:alen-1] + b[0:blen-1] | |
| 87 | +// prereq: alen >= blen, sum has room for alen+1 digits | |
| 88 | +void mpvecadd(mpdigit *a, int alen, mpdigit *b, int blen, mpdigit *sum); | |
| 89 | + | |
| 90 | +// diff[0:alen-1] = a[0:alen-1] - b[0:blen-1] | |
| 91 | +// prereq: alen >= blen, diff has room for alen digits | |
| 92 | +void mpvecsub(mpdigit *a, int alen, mpdigit *b, int blen, mpdigit *diff); | |
| 93 | + | |
| 94 | +// p[0:n] += m * b[0:n-1] | |
| 95 | +// prereq: p has room for n+1 digits | |
| 96 | +void mpvecdigmuladd(mpdigit *b, int n, mpdigit m, mpdigit *p); | |
| 97 | + | |
| 98 | +// p[0:n] -= m * b[0:n-1] | |
| 99 | +// prereq: p has room for n+1 digits | |
| 100 | +int mpvecdigmulsub(mpdigit *b, int n, mpdigit m, mpdigit *p); | |
| 101 | + | |
| 102 | +// p[0:alen*blen-1] = a[0:alen-1] * b[0:blen-1] | |
| 103 | +// prereq: alen >= blen, p has room for m*n digits | |
| 104 | +void mpvecmul(mpdigit *a, int alen, mpdigit *b, int blen, mpdigit *p); | |
| 105 | + | |
| 106 | +// sign of a - b or zero if the same | |
| 107 | +int mpveccmp(mpdigit *a, int alen, mpdigit *b, int blen); | |
| 108 | + | |
| 109 | +// divide the 2 digit dividend by the one digit divisor and stick in quotient | |
| 110 | +// we assume that the result is one digit - overflow is all 1's | |
| 111 | +void mpdigdiv(mpdigit *dividend, mpdigit divisor, mpdigit *quotient); | |
| 112 | + | |
| 113 | +// playing with magnitudes | |
| 114 | +int mpmagcmp(mpint *b1, mpint *b2); | |
| 115 | +void mpmagadd(mpint *b1, mpint *b2, mpint *sum); // sum = b1+b2 | |
| 116 | +void mpmagsub(mpint *b1, mpint *b2, mpint *sum); // sum = b1+b2 | |
| 117 | + | |
| 118 | +// chinese remainder theorem | |
| 119 | +typedef struct CRTpre CRTpre; // precomputed values for converting | |
| 120 | + // twixt residues and mpint | |
| 121 | +typedef struct CRTres CRTres; // residue form of an mpint | |
| 122 | + | |
| 123 | +struct CRTres | |
| 124 | +{ | |
| 125 | + int n; // number of residues | |
| 126 | + mpint *r[1]; // residues | |
| 127 | +}; | |
| 128 | + | |
| 129 | +CRTpre* crtpre(int, mpint**); // precompute conversion values | |
| 130 | +CRTres* crtin(CRTpre*, mpint*); // convert mpint to residues | |
| 131 | +void crtout(CRTpre*, CRTres*, mpint*); // convert residues to mpint | |
| 132 | +void crtprefree(CRTpre*); | |
| 133 | +void crtresfree(CRTres*); | |
| 134 | + | |
| @@ -0,0 +1,26 @@ | ||
| 1 | +#include "dtos.h" | |
| 2 | + | |
| 3 | +/* avoid name conflicts */ | |
| 4 | +#undef accept | |
| 5 | +#undef listen | |
| 6 | + | |
| 7 | +/* sys calls */ | |
| 8 | +#undef bind | |
| 9 | +#undef chdir | |
| 10 | +#undef close | |
| 11 | +#undef create | |
| 12 | +#undef dup | |
| 13 | +#undef export | |
| 14 | +#undef fstat | |
| 15 | +#undef fwstat | |
| 16 | +#undef mount | |
| 17 | +#undef open | |
| 18 | +#undef start | |
| 19 | +#undef read | |
| 20 | +#undef remove | |
| 21 | +#undef seek | |
| 22 | +#undef stat | |
| 23 | +#undef write | |
| 24 | +#undef wstat | |
| 25 | +#undef unmount | |
| 26 | +#undef pipe | |
| @@ -0,0 +1,14 @@ | ||
| 1 | +#include <stdio.h> | |
| 2 | +#include <stdlib.h> | |
| 3 | +#include <string.h> | |
| 4 | +#include <math.h> | |
| 5 | +#include <fcntl.h> | |
| 6 | +#include <setjmp.h> | |
| 7 | +#include <time.h> | |
| 8 | +#include <assert.h> | |
| 9 | +#include <unistd.h> | |
| 10 | +#include <stdarg.h> | |
| 11 | + | |
| 12 | + | |
| 13 | +typedef long long p9_vlong; | |
| 14 | +typedef unsigned long long p9_uvlong; | |
| @@ -0,0 +1,65 @@ | ||
| 1 | +/* sys calls */ | |
| 2 | +#define bind sysbind | |
| 3 | +#define chdir syschdir | |
| 4 | +#define close sysclose | |
| 5 | +#define create syscreate | |
| 6 | +#define dup sysdup | |
| 7 | +#define export sysexport | |
| 8 | +#define fstat sysfstat | |
| 9 | +#define fwstat sysfwstat | |
| 10 | +#define mount sysmount | |
| 11 | +#define open sysopen | |
| 12 | +#define read sysread | |
| 13 | +#define remove sysremove | |
| 14 | +#define seek sysseek | |
| 15 | +#define stat sysstat | |
| 16 | +#define write syswrite | |
| 17 | +#define wstat syswstat | |
| 18 | +#define unmount sysunmount | |
| 19 | +#define pipe syspipe | |
| 20 | +#define rendezvous sysrendezvous | |
| 21 | +#define getpid sysgetpid | |
| 22 | +#define time systime | |
| 23 | +#define nsec sysnsec | |
| 24 | +#define pread syspread | |
| 25 | +#define pwrite syspwrite | |
| 26 | + | |
| 27 | +extern int bind(char*, char*, int); | |
| 28 | +extern int chdir(char*); | |
| 29 | +extern int close(int); | |
| 30 | +extern int create(char*, int, ulong); | |
| 31 | +extern int dup(int, int); | |
| 32 | +extern int export(int); | |
| 33 | +extern int fstat(int, uchar*, int); | |
| 34 | +extern int fwstat(int, uchar*, int); | |
| 35 | +extern int mount(int, int, char*, int, char*); | |
| 36 | +extern int unmount(char*, char*); | |
| 37 | +extern int open(char*, int); | |
| 38 | +extern int pipe(int*); | |
| 39 | +extern long read(int, void*, long); | |
| 40 | +extern long readn(int, void*, long); | |
| 41 | +extern int remove(char*); | |
| 42 | +extern vlong seek(int, vlong, int); | |
| 43 | +extern int stat(char*, uchar*, int); | |
| 44 | +extern long write(int, void*, long); | |
| 45 | +extern int wstat(char*, uchar*, int); | |
| 46 | + | |
| 47 | +extern Dir *dirstat(char*); | |
| 48 | +extern Dir *dirfstat(int); | |
| 49 | +extern int dirwstat(char*, Dir*); | |
| 50 | +extern int dirfwstat(int, Dir*); | |
| 51 | +extern long dirread(int, Dir*, long); | |
| 52 | + | |
| 53 | +/* | |
| 54 | + * network dialing and authentication | |
| 55 | + */ | |
| 56 | +#define NETPATHLEN 40 | |
| 57 | +extern int accept(int, char*); | |
| 58 | +extern int announce(char*, char*); | |
| 59 | +extern int dial(char*, char*, char*, int*); | |
| 60 | +extern int hangup(int); | |
| 61 | +extern int listen(char*, char*); | |
| 62 | +extern char *netmkaddr(char*, char*, char*); | |
| 63 | +extern int reject(int, char*, char*); | |
| 64 | + | |
| 65 | +extern char* argv0; | |
Empty file added.
| @@ -0,0 +1,6 @@ | ||
| 1 | +#include <stdio.h> | |
| 2 | + | |
| 3 | +void | |
| 4 | +main(void) | |
| 5 | +{ | |
| 6 | +} | |
| @@ -0,0 +1,50 @@ | ||
| 1 | +LIB=libkern.a | |
| 2 | +CC=gcc | |
| 3 | +CFLAGS=-I../include -I. -c -ggdb -D_THREAD_SAFE -pthread | |
| 4 | +O=o | |
| 5 | +#CC=cl | |
| 6 | +#CFLAGS=-c -nologo -W3 -YX -Zi -MT -Zl -I../include -DWINDOWS | |
| 7 | +#O=obj | |
| 8 | + | |
| 9 | +OFILES=\ | |
| 10 | + allocb.$O\ | |
| 11 | + cache.$O\ | |
| 12 | + chan.$O\ | |
| 13 | + data.$O\ | |
| 14 | + dev.$O\ | |
| 15 | + devcons.$O\ | |
| 16 | + devdraw.$O\ | |
| 17 | + devfs.$O\ | |
| 18 | + devip.$O\ | |
| 19 | + devip-posix.$O\ | |
| 20 | + devmnt.$O\ | |
| 21 | + devmouse.$O\ | |
| 22 | + devpipe.$O\ | |
| 23 | + devroot.$O\ | |
| 24 | + devssl.$O\ | |
| 25 | + devtab.$O\ | |
| 26 | + error.$O\ | |
| 27 | + parse.$O\ | |
| 28 | + pgrp.$O\ | |
| 29 | + posix.$O\ | |
| 30 | + procinit.$O\ | |
| 31 | + rwlock.$O\ | |
| 32 | + sleep.$O\ | |
| 33 | + smalloc.$O\ | |
| 34 | + stub.$O\ | |
| 35 | + sysfile.$O\ | |
| 36 | + sysproc.$O\ | |
| 37 | + qio.$O\ | |
| 38 | + qlock.$O\ | |
| 39 | + term.$O\ | |
| 40 | + todo.$O\ | |
| 41 | + uart.$O\ | |
| 42 | + waserror.$O | |
| 43 | + | |
| 44 | +$(LIB): $(OFILES) | |
| 45 | + ar r $(LIB) $(OFILES) | |
| 46 | + ranlib $(LIB) | |
| 47 | + | |
| 48 | +%.$O: %.c | |
| 49 | + $(CC) $(CFLAGS) $*.c | |
| 50 | + | |
| @@ -0,0 +1,165 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +enum | |
| 8 | +{ | |
| 9 | + Hdrspc = 64, /* leave room for high-level headers */ | |
| 10 | + Bdead = 0x51494F42, /* "QIOB" */ | |
| 11 | +}; | |
| 12 | + | |
| 13 | +struct | |
| 14 | +{ | |
| 15 | + Lock lk; | |
| 16 | + ulong bytes; | |
| 17 | +} ialloc; | |
| 18 | + | |
| 19 | +static Block* | |
| 20 | +_allocb(int size) | |
| 21 | +{ | |
| 22 | + Block *b; | |
| 23 | + ulong addr; | |
| 24 | + | |
| 25 | + if((b = mallocz(sizeof(Block)+size+Hdrspc, 0)) == nil) | |
| 26 | + return nil; | |
| 27 | + | |
| 28 | + b->next = nil; | |
| 29 | + b->list = nil; | |
| 30 | + b->free = 0; | |
| 31 | + b->flag = 0; | |
| 32 | + | |
| 33 | + /* align start of data portion by rounding up */ | |
| 34 | + addr = (ulong)b; | |
| 35 | + addr = ROUND(addr + sizeof(Block), BLOCKALIGN); | |
| 36 | + b->base = (uchar*)addr; | |
| 37 | + | |
| 38 | + /* align end of data portion by rounding down */ | |
| 39 | + b->lim = ((uchar*)b) + sizeof(Block)+size+Hdrspc; | |
| 40 | + addr = (ulong)(b->lim); | |
| 41 | + addr = addr & ~(BLOCKALIGN-1); | |
| 42 | + b->lim = (uchar*)addr; | |
| 43 | + | |
| 44 | + /* leave sluff at beginning for added headers */ | |
| 45 | + b->rp = b->lim - ROUND(size, BLOCKALIGN); | |
| 46 | + if(b->rp < b->base) | |
| 47 | + panic("_allocb"); | |
| 48 | + b->wp = b->rp; | |
| 49 | + | |
| 50 | + return b; | |
| 51 | +} | |
| 52 | + | |
| 53 | +Block* | |
| 54 | +allocb(int size) | |
| 55 | +{ | |
| 56 | + Block *b; | |
| 57 | + | |
| 58 | + /* | |
| 59 | + * Check in a process and wait until successful. | |
| 60 | + * Can still error out of here, though. | |
| 61 | + */ | |
| 62 | + if(up == nil) | |
| 63 | + panic("allocb without up: %luX\n", getcallerpc(&size)); | |
| 64 | + if((b = _allocb(size)) == nil){ | |
| 65 | + panic("allocb: no memory for %d bytes\n", size); | |
| 66 | + } | |
| 67 | + setmalloctag(b, getcallerpc(&size)); | |
| 68 | + | |
| 69 | + return b; | |
| 70 | +} | |
| 71 | + | |
| 72 | +Block* | |
| 73 | +iallocb(int size) | |
| 74 | +{ | |
| 75 | + Block *b; | |
| 76 | + static int m1, m2; | |
| 77 | + | |
| 78 | + if(ialloc.bytes > conf.ialloc){ | |
| 79 | + if((m1++%10000)==0) | |
| 80 | + print("iallocb: limited %lud/%lud\n", | |
| 81 | + ialloc.bytes, conf.ialloc); | |
| 82 | + return 0; | |
| 83 | + } | |
| 84 | + | |
| 85 | + if((b = _allocb(size)) == nil){ | |
| 86 | + if((m2++%10000)==0) | |
| 87 | + print("iallocb: no memory %lud/%lud\n", | |
| 88 | + ialloc.bytes, conf.ialloc); | |
| 89 | + return nil; | |
| 90 | + } | |
| 91 | + setmalloctag(b, getcallerpc(&size)); | |
| 92 | + b->flag = BINTR; | |
| 93 | + | |
| 94 | + ilock(&ialloc.lk); | |
| 95 | + ialloc.bytes += b->lim - b->base; | |
| 96 | + iunlock(&ialloc.lk); | |
| 97 | + | |
| 98 | + return b; | |
| 99 | +} | |
| 100 | + | |
| 101 | +void | |
| 102 | +freeb(Block *b) | |
| 103 | +{ | |
| 104 | + void *dead = (void*)Bdead; | |
| 105 | + | |
| 106 | + if(b == nil) | |
| 107 | + return; | |
| 108 | + | |
| 109 | + /* | |
| 110 | + * drivers which perform non cache coherent DMA manage their own buffer | |
| 111 | + * pool of uncached buffers and provide their own free routine. | |
| 112 | + */ | |
| 113 | + if(b->free) { | |
| 114 | + b->free(b); | |
| 115 | + return; | |
| 116 | + } | |
| 117 | + if(b->flag & BINTR) { | |
| 118 | + ilock(&ialloc.lk); | |
| 119 | + ialloc.bytes -= b->lim - b->base; | |
| 120 | + iunlock(&ialloc.lk); | |
| 121 | + } | |
| 122 | + | |
| 123 | + /* poison the block in case someone is still holding onto it */ | |
| 124 | + b->next = dead; | |
| 125 | + b->rp = dead; | |
| 126 | + b->wp = dead; | |
| 127 | + b->lim = dead; | |
| 128 | + b->base = dead; | |
| 129 | + | |
| 130 | + free(b); | |
| 131 | +} | |
| 132 | + | |
| 133 | +void | |
| 134 | +checkb(Block *b, char *msg) | |
| 135 | +{ | |
| 136 | + void *dead = (void*)Bdead; | |
| 137 | + | |
| 138 | + if(b == dead) | |
| 139 | + panic("checkb b %s %lux", msg, b); | |
| 140 | + if(b->base == dead || b->lim == dead || b->next == dead | |
| 141 | + || b->rp == dead || b->wp == dead){ | |
| 142 | + print("checkb: base 0x%8.8luX lim 0x%8.8luX next 0x%8.8luX\n", | |
| 143 | + b->base, b->lim, b->next); | |
| 144 | + print("checkb: rp 0x%8.8luX wp 0x%8.8luX\n", b->rp, b->wp); | |
| 145 | + panic("checkb dead: %s\n", msg); | |
| 146 | + } | |
| 147 | + | |
| 148 | + if(b->base > b->lim) | |
| 149 | + panic("checkb 0 %s %lux %lux", msg, b->base, b->lim); | |
| 150 | + if(b->rp < b->base) | |
| 151 | + panic("checkb 1 %s %lux %lux", msg, b->base, b->rp); | |
| 152 | + if(b->wp < b->base) | |
| 153 | + panic("checkb 2 %s %lux %lux", msg, b->base, b->wp); | |
| 154 | + if(b->rp > b->lim) | |
| 155 | + panic("checkb 3 %s %lux %lux", msg, b->rp, b->lim); | |
| 156 | + if(b->wp > b->lim) | |
| 157 | + panic("checkb 4 %s %lux %lux", msg, b->wp, b->lim); | |
| 158 | + | |
| 159 | +} | |
| 160 | + | |
| 161 | +void | |
| 162 | +iallocsummary(void) | |
| 163 | +{ | |
| 164 | + print("ialloc %lud/%lud\n", ialloc.bytes, conf.ialloc); | |
| 165 | +} | |
| @@ -0,0 +1,46 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | + | |
| 8 | +void | |
| 9 | +cinit(void) | |
| 10 | +{ | |
| 11 | +} | |
| 12 | + | |
| 13 | +void | |
| 14 | +copen(Chan *c) | |
| 15 | +{ | |
| 16 | + USED(c); | |
| 17 | +} | |
| 18 | + | |
| 19 | +int | |
| 20 | +cread(Chan *c, uchar *buf, int len, vlong off) | |
| 21 | +{ | |
| 22 | + USED(c); | |
| 23 | + USED(buf); | |
| 24 | + USED(len); | |
| 25 | + USED(off); | |
| 26 | + | |
| 27 | + return 0; | |
| 28 | +} | |
| 29 | + | |
| 30 | +void | |
| 31 | +cupdate(Chan *c, uchar *buf, int len, vlong off) | |
| 32 | +{ | |
| 33 | + USED(c); | |
| 34 | + USED(buf); | |
| 35 | + USED(len); | |
| 36 | + USED(off); | |
| 37 | +} | |
| 38 | + | |
| 39 | +void | |
| 40 | +cwrite(Chan* c, uchar *buf, int len, vlong off) | |
| 41 | +{ | |
| 42 | + USED(c); | |
| 43 | + USED(buf); | |
| 44 | + USED(len); | |
| 45 | + USED(off); | |
| 46 | +} | |
| @@ -0,0 +1,1496 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +int chandebug=0; /* toggled by sysr1 */ | |
| 8 | +QLock chanprint; /* probably asking for trouble (deadlocks) -rsc */ | |
| 9 | + | |
| 10 | +int domount(Chan**, Mhead**); | |
| 11 | + | |
| 12 | +void | |
| 13 | +dumpmount(void) /* DEBUGGING */ | |
| 14 | +{ | |
| 15 | + Pgrp *pg; | |
| 16 | + Mount *t; | |
| 17 | + Mhead **h, **he, *f; | |
| 18 | + | |
| 19 | + if(up == nil){ | |
| 20 | + print("no process for dumpmount\n"); | |
| 21 | + return; | |
| 22 | + } | |
| 23 | + pg = up->pgrp; | |
| 24 | + if(pg == nil){ | |
| 25 | + print("no pgrp for dumpmount\n"); | |
| 26 | + return; | |
| 27 | + } | |
| 28 | + rlock(&pg->ns); | |
| 29 | + if(waserror()) { | |
| 30 | + runlock(&pg->ns); | |
| 31 | + nexterror(); | |
| 32 | + } | |
| 33 | + | |
| 34 | + he = &pg->mnthash[MNTHASH]; | |
| 35 | + for(h = pg->mnthash; h < he; h++) { | |
| 36 | + for(f = *h; f; f = f->hash) { | |
| 37 | + print("head: %p: %s 0x%llux.%lud %C %lud -> \n", f, | |
| 38 | + f->from->name->s, f->from->qid.path, | |
| 39 | + f->from->qid.vers, devtab[f->from->type]->dc, | |
| 40 | + f->from->dev); | |
| 41 | + for(t = f->mount; t; t = t->next) | |
| 42 | + print("\t%p: %s (umh %p) (path %.8llux dev %C %lud)\n", t, t->to->name->s, t->to->umh, t->to->qid.path, devtab[t->to->type]->dc, t->to->dev); | |
| 43 | + } | |
| 44 | + } | |
| 45 | + poperror(); | |
| 46 | + runlock(&pg->ns); | |
| 47 | +} | |
| 48 | + | |
| 49 | + | |
| 50 | +char* | |
| 51 | +c2name(Chan *c) /* DEBUGGING */ | |
| 52 | +{ | |
| 53 | + if(c == nil) | |
| 54 | + return "<nil chan>"; | |
| 55 | + if(c->name == nil) | |
| 56 | + return "<nil name>"; | |
| 57 | + if(c->name->s == nil) | |
| 58 | + return "<nil name.s>"; | |
| 59 | + return c->name->s; | |
| 60 | +} | |
| 61 | + | |
| 62 | +enum | |
| 63 | +{ | |
| 64 | + CNAMESLOP = 20 | |
| 65 | +}; | |
| 66 | + | |
| 67 | +struct | |
| 68 | +{ | |
| 69 | + Lock lk; | |
| 70 | + int fid; | |
| 71 | + Chan *free; | |
| 72 | + Chan *list; | |
| 73 | +}chanalloc; | |
| 74 | + | |
| 75 | +typedef struct Elemlist Elemlist; | |
| 76 | + | |
| 77 | +struct Elemlist | |
| 78 | +{ | |
| 79 | + char *name; /* copy of name, so '/' can be overwritten */ | |
| 80 | + int nelems; | |
| 81 | + char **elems; | |
| 82 | + int *off; | |
| 83 | + int mustbedir; | |
| 84 | +}; | |
| 85 | + | |
| 86 | +#define SEP(c) ((c) == 0 || (c) == '/') | |
| 87 | +void cleancname(Cname*); | |
| 88 | + | |
| 89 | +int | |
| 90 | +isdotdot(char *p) | |
| 91 | +{ | |
| 92 | + return p[0]=='.' && p[1]=='.' && p[2]=='\0'; | |
| 93 | +} | |
| 94 | + | |
| 95 | +int | |
| 96 | +incref(Ref *r) | |
| 97 | +{ | |
| 98 | + int x; | |
| 99 | + | |
| 100 | + lock(&r->lk); | |
| 101 | + x = ++r->ref; | |
| 102 | + unlock(&r->lk); | |
| 103 | + return x; | |
| 104 | +} | |
| 105 | + | |
| 106 | +int | |
| 107 | +decref(Ref *r) | |
| 108 | +{ | |
| 109 | + int x; | |
| 110 | + | |
| 111 | + lock(&r->lk); | |
| 112 | + x = --r->ref; | |
| 113 | + unlock(&r->lk); | |
| 114 | + if(x < 0) | |
| 115 | + panic("decref, pc=0x%lux", getcallerpc(&r)); | |
| 116 | + | |
| 117 | + return x; | |
| 118 | +} | |
| 119 | + | |
| 120 | +/* | |
| 121 | + * Rather than strncpy, which zeros the rest of the buffer, kstrcpy | |
| 122 | + * truncates if necessary, always zero terminates, does not zero fill, | |
| 123 | + * and puts ... at the end of the string if it's too long. Usually used to | |
| 124 | + * save a string in up->genbuf; | |
| 125 | + */ | |
| 126 | +void | |
| 127 | +kstrcpy(char *s, char *t, int ns) | |
| 128 | +{ | |
| 129 | + int nt; | |
| 130 | + | |
| 131 | + nt = strlen(t); | |
| 132 | + if(nt+1 <= ns){ | |
| 133 | + memmove(s, t, nt+1); | |
| 134 | + return; | |
| 135 | + } | |
| 136 | + /* too long */ | |
| 137 | + if(ns < 4){ | |
| 138 | + /* but very short! */ | |
| 139 | + strncpy(s, t, ns); | |
| 140 | + return; | |
| 141 | + } | |
| 142 | + /* truncate with ... at character boundary (very rare case) */ | |
| 143 | + memmove(s, t, ns-4); | |
| 144 | + ns -= 4; | |
| 145 | + s[ns] = '\0'; | |
| 146 | + /* look for first byte of UTF-8 sequence by skipping continuation bytes */ | |
| 147 | + while(ns>0 && (s[--ns]&0xC0)==0x80) | |
| 148 | + ; | |
| 149 | + strcpy(s+ns, "..."); | |
| 150 | +} | |
| 151 | + | |
| 152 | +int | |
| 153 | +emptystr(char *s) | |
| 154 | +{ | |
| 155 | + if(s == nil) | |
| 156 | + return 1; | |
| 157 | + if(s[0] == '\0') | |
| 158 | + return 1; | |
| 159 | + return 0; | |
| 160 | +} | |
| 161 | + | |
| 162 | +/* | |
| 163 | + * Atomically replace *p with copy of s | |
| 164 | + */ | |
| 165 | +void | |
| 166 | +kstrdup(char **p, char *s) | |
| 167 | +{ | |
| 168 | + int n; | |
| 169 | + char *t, *prev; | |
| 170 | + static Lock l; | |
| 171 | + | |
| 172 | + n = strlen(s)+1; | |
| 173 | + /* if it's a user, we can wait for memory; if not, something's very wrong */ | |
| 174 | + if(up){ | |
| 175 | + t = smalloc(n); | |
| 176 | + setmalloctag(t, getcallerpc(&p)); | |
| 177 | + }else{ | |
| 178 | + t = malloc(n); | |
| 179 | + if(t == nil) | |
| 180 | + panic("kstrdup: no memory"); | |
| 181 | + } | |
| 182 | + memmove(t, s, n); | |
| 183 | + prev = *p; | |
| 184 | + *p = t; | |
| 185 | + free(prev); | |
| 186 | +} | |
| 187 | + | |
| 188 | +void | |
| 189 | +chandevreset(void) | |
| 190 | +{ | |
| 191 | + int i; | |
| 192 | + | |
| 193 | + for(i=0; devtab[i] != nil; i++) | |
| 194 | + devtab[i]->reset(); | |
| 195 | +} | |
| 196 | + | |
| 197 | +void | |
| 198 | +chandevinit(void) | |
| 199 | +{ | |
| 200 | + int i; | |
| 201 | + | |
| 202 | + for(i=0; devtab[i] != nil; i++) | |
| 203 | + devtab[i]->init(); | |
| 204 | +} | |
| 205 | + | |
| 206 | +void | |
| 207 | +chandevshutdown(void) | |
| 208 | +{ | |
| 209 | + int i; | |
| 210 | + | |
| 211 | + /* shutdown in reverse order */ | |
| 212 | + for(i=0; devtab[i] != nil; i++) | |
| 213 | + ; | |
| 214 | + for(i--; i >= 0; i--) | |
| 215 | + devtab[i]->shutdown(); | |
| 216 | +} | |
| 217 | + | |
| 218 | +Chan* | |
| 219 | +newchan(void) | |
| 220 | +{ | |
| 221 | + Chan *c; | |
| 222 | + | |
| 223 | + lock(&chanalloc.lk); | |
| 224 | + c = chanalloc.free; | |
| 225 | + if(c != 0) | |
| 226 | + chanalloc.free = c->next; | |
| 227 | + unlock(&chanalloc.lk); | |
| 228 | + | |
| 229 | + if(c == nil) { | |
| 230 | + c = smalloc(sizeof(Chan)); | |
| 231 | + lock(&chanalloc.lk); | |
| 232 | + c->fid = ++chanalloc.fid; | |
| 233 | + c->link = chanalloc.list; | |
| 234 | + chanalloc.list = c; | |
| 235 | + unlock(&chanalloc.lk); | |
| 236 | + } | |
| 237 | + | |
| 238 | + /* if you get an error before associating with a dev, | |
| 239 | + close calls rootclose, a nop */ | |
| 240 | + c->type = 0; | |
| 241 | + c->flag = 0; | |
| 242 | + c->ref.ref = 1; | |
| 243 | + c->dev = 0; | |
| 244 | + c->offset = 0; | |
| 245 | + c->iounit = 0; | |
| 246 | + c->umh = 0; | |
| 247 | + c->uri = 0; | |
| 248 | + c->dri = 0; | |
| 249 | + c->aux = 0; | |
| 250 | + c->mchan = 0; | |
| 251 | + c->mcp = 0; | |
| 252 | + c->mux = 0; | |
| 253 | + memset(&c->mqid, 0, sizeof(c->mqid)); | |
| 254 | + c->name = 0; | |
| 255 | + return c; | |
| 256 | +} | |
| 257 | + | |
| 258 | +static Ref ncname; | |
| 259 | + | |
| 260 | +Cname* | |
| 261 | +newcname(char *s) | |
| 262 | +{ | |
| 263 | + Cname *n; | |
| 264 | + int i; | |
| 265 | + | |
| 266 | + n = smalloc(sizeof(Cname)); | |
| 267 | + i = strlen(s); | |
| 268 | + n->len = i; | |
| 269 | + n->alen = i+CNAMESLOP; | |
| 270 | + n->s = smalloc(n->alen); | |
| 271 | + memmove(n->s, s, i+1); | |
| 272 | + n->ref.ref = 1; | |
| 273 | + incref(&ncname); | |
| 274 | + return n; | |
| 275 | +} | |
| 276 | + | |
| 277 | +void | |
| 278 | +cnameclose(Cname *n) | |
| 279 | +{ | |
| 280 | + if(n == nil) | |
| 281 | + return; | |
| 282 | + if(decref(&n->ref)) | |
| 283 | + return; | |
| 284 | + decref(&ncname); | |
| 285 | + free(n->s); | |
| 286 | + free(n); | |
| 287 | +} | |
| 288 | + | |
| 289 | +Cname* | |
| 290 | +addelem(Cname *n, char *s) | |
| 291 | +{ | |
| 292 | + int i, a; | |
| 293 | + char *t; | |
| 294 | + Cname *new; | |
| 295 | + | |
| 296 | + if(s[0]=='.' && s[1]=='\0') | |
| 297 | + return n; | |
| 298 | + | |
| 299 | + if(n->ref.ref > 1){ | |
| 300 | + /* copy on write */ | |
| 301 | + new = newcname(n->s); | |
| 302 | + cnameclose(n); | |
| 303 | + n = new; | |
| 304 | + } | |
| 305 | + | |
| 306 | + i = strlen(s); | |
| 307 | + if(n->len+1+i+1 > n->alen){ | |
| 308 | + a = n->len+1+i+1 + CNAMESLOP; | |
| 309 | + t = smalloc(a); | |
| 310 | + memmove(t, n->s, n->len+1); | |
| 311 | + free(n->s); | |
| 312 | + n->s = t; | |
| 313 | + n->alen = a; | |
| 314 | + } | |
| 315 | + if(n->len>0 && n->s[n->len-1]!='/' && s[0]!='/') /* don't insert extra slash if one is present */ | |
| 316 | + n->s[n->len++] = '/'; | |
| 317 | + memmove(n->s+n->len, s, i+1); | |
| 318 | + n->len += i; | |
| 319 | + if(isdotdot(s)) | |
| 320 | + cleancname(n); | |
| 321 | + return n; | |
| 322 | +} | |
| 323 | + | |
| 324 | +void | |
| 325 | +chanfree(Chan *c) | |
| 326 | +{ | |
| 327 | + c->flag = CFREE; | |
| 328 | + | |
| 329 | + if(c->umh != nil){ | |
| 330 | + putmhead(c->umh); | |
| 331 | + c->umh = nil; | |
| 332 | + } | |
| 333 | + if(c->umc != nil){ | |
| 334 | + cclose(c->umc); | |
| 335 | + c->umc = nil; | |
| 336 | + } | |
| 337 | + if(c->mux != nil){ | |
| 338 | + muxclose(c->mux); | |
| 339 | + c->mux = nil; | |
| 340 | + } | |
| 341 | + if(c->mchan != nil){ | |
| 342 | + cclose(c->mchan); | |
| 343 | + c->mchan = nil; | |
| 344 | + } | |
| 345 | + | |
| 346 | + cnameclose(c->name); | |
| 347 | + | |
| 348 | + lock(&chanalloc.lk); | |
| 349 | + c->next = chanalloc.free; | |
| 350 | + chanalloc.free = c; | |
| 351 | + unlock(&chanalloc.lk); | |
| 352 | +} | |
| 353 | + | |
| 354 | +void | |
| 355 | +cclose(Chan *c) | |
| 356 | +{ | |
| 357 | + if(c->flag&CFREE) | |
| 358 | + panic("cclose %lux", getcallerpc(&c)); | |
| 359 | + | |
| 360 | + if(decref(&c->ref)) | |
| 361 | + return; | |
| 362 | + | |
| 363 | + if(!waserror()){ | |
| 364 | + devtab[c->type]->close(c); | |
| 365 | + poperror(); | |
| 366 | + } | |
| 367 | + chanfree(c); | |
| 368 | +} | |
| 369 | + | |
| 370 | +/* | |
| 371 | + * Make sure we have the only copy of c. (Copy on write.) | |
| 372 | + */ | |
| 373 | +Chan* | |
| 374 | +cunique(Chan *c) | |
| 375 | +{ | |
| 376 | + Chan *nc; | |
| 377 | + | |
| 378 | + if(c->ref.ref != 1) { | |
| 379 | + nc = cclone(c); | |
| 380 | + cclose(c); | |
| 381 | + c = nc; | |
| 382 | + } | |
| 383 | + | |
| 384 | + return c; | |
| 385 | +} | |
| 386 | + | |
| 387 | +int | |
| 388 | +eqqid(Qid a, Qid b) | |
| 389 | +{ | |
| 390 | + return a.path==b.path && a.vers==b.vers; | |
| 391 | +} | |
| 392 | + | |
| 393 | +int | |
| 394 | +eqchan(Chan *a, Chan *b, int pathonly) | |
| 395 | +{ | |
| 396 | + if(a->qid.path != b->qid.path) | |
| 397 | + return 0; | |
| 398 | + if(!pathonly && a->qid.vers!=b->qid.vers) | |
| 399 | + return 0; | |
| 400 | + if(a->type != b->type) | |
| 401 | + return 0; | |
| 402 | + if(a->dev != b->dev) | |
| 403 | + return 0; | |
| 404 | + return 1; | |
| 405 | +} | |
| 406 | + | |
| 407 | +int | |
| 408 | +eqchantdqid(Chan *a, int type, int dev, Qid qid, int pathonly) | |
| 409 | +{ | |
| 410 | + if(a->qid.path != qid.path) | |
| 411 | + return 0; | |
| 412 | + if(!pathonly && a->qid.vers!=qid.vers) | |
| 413 | + return 0; | |
| 414 | + if(a->type != type) | |
| 415 | + return 0; | |
| 416 | + if(a->dev != dev) | |
| 417 | + return 0; | |
| 418 | + return 1; | |
| 419 | +} | |
| 420 | + | |
| 421 | +Mhead* | |
| 422 | +newmhead(Chan *from) | |
| 423 | +{ | |
| 424 | + Mhead *mh; | |
| 425 | + | |
| 426 | + mh = smalloc(sizeof(Mhead)); | |
| 427 | + mh->ref.ref = 1; | |
| 428 | + mh->from = from; | |
| 429 | + incref(&from->ref); | |
| 430 | + | |
| 431 | +/* | |
| 432 | + n = from->name->len; | |
| 433 | + if(n >= sizeof(mh->fromname)) | |
| 434 | + n = sizeof(mh->fromname)-1; | |
| 435 | + memmove(mh->fromname, from->name->s, n); | |
| 436 | + mh->fromname[n] = 0; | |
| 437 | +*/ | |
| 438 | + return mh; | |
| 439 | +} | |
| 440 | + | |
| 441 | +int | |
| 442 | +cmount(Chan **newp, Chan *old, int flag, char *spec) | |
| 443 | +{ | |
| 444 | + Pgrp *pg; | |
| 445 | + int order, flg; | |
| 446 | + Mhead *m, **l, *mh; | |
| 447 | + Mount *nm, *f, *um, **h; | |
| 448 | + Chan *new; | |
| 449 | + | |
| 450 | + if(QTDIR & (old->qid.type^(*newp)->qid.type)) | |
| 451 | + error(Emount); | |
| 452 | + | |
| 453 | +if(old->umh)print("cmount old extra umh\n"); | |
| 454 | + | |
| 455 | + order = flag&MORDER; | |
| 456 | + | |
| 457 | + if((old->qid.type&QTDIR)==0 && order != MREPL) | |
| 458 | + error(Emount); | |
| 459 | + | |
| 460 | + new = *newp; | |
| 461 | + mh = new->umh; | |
| 462 | + | |
| 463 | + /* | |
| 464 | + * Not allowed to bind when the old directory | |
| 465 | + * is itself a union. (Maybe it should be allowed, but I don't see | |
| 466 | + * what the semantics would be.) | |
| 467 | + * | |
| 468 | + * We need to check mh->mount->next to tell unions apart from | |
| 469 | + * simple mount points, so that things like | |
| 470 | + * mount -c fd /root | |
| 471 | + * bind -c /root / | |
| 472 | + * work. The check of mount->mflag catches things like | |
| 473 | + * mount fd /root | |
| 474 | + * bind -c /root / | |
| 475 | + * | |
| 476 | + * This is far more complicated than it should be, but I don't | |
| 477 | + * see an easier way at the moment. -rsc | |
| 478 | + */ | |
| 479 | + if((flag&MCREATE) && mh && mh->mount | |
| 480 | + && (mh->mount->next || !(mh->mount->mflag&MCREATE))) | |
| 481 | + error(Emount); | |
| 482 | + | |
| 483 | + pg = up->pgrp; | |
| 484 | + wlock(&pg->ns); | |
| 485 | + | |
| 486 | + l = &MOUNTH(pg, old->qid); | |
| 487 | + for(m = *l; m; m = m->hash) { | |
| 488 | + if(eqchan(m->from, old, 1)) | |
| 489 | + break; | |
| 490 | + l = &m->hash; | |
| 491 | + } | |
| 492 | + | |
| 493 | + if(m == nil) { | |
| 494 | + /* | |
| 495 | + * nothing mounted here yet. create a mount | |
| 496 | + * head and add to the hash table. | |
| 497 | + */ | |
| 498 | + m = newmhead(old); | |
| 499 | + *l = m; | |
| 500 | + | |
| 501 | + /* | |
| 502 | + * if this is a union mount, add the old | |
| 503 | + * node to the mount chain. | |
| 504 | + */ | |
| 505 | + if(order != MREPL) | |
| 506 | + m->mount = newmount(m, old, 0, 0); | |
| 507 | + } | |
| 508 | + wlock(&m->lock); | |
| 509 | + if(waserror()){ | |
| 510 | + wunlock(&m->lock); | |
| 511 | + nexterror(); | |
| 512 | + } | |
| 513 | + wunlock(&pg->ns); | |
| 514 | + | |
| 515 | + nm = newmount(m, new, flag, spec); | |
| 516 | + if(mh != nil && mh->mount != nil) { | |
| 517 | + /* | |
| 518 | + * copy a union when binding it onto a directory | |
| 519 | + */ | |
| 520 | + flg = order; | |
| 521 | + if(order == MREPL) | |
| 522 | + flg = MAFTER; | |
| 523 | + h = &nm->next; | |
| 524 | + um = mh->mount; | |
| 525 | + for(um = um->next; um; um = um->next) { | |
| 526 | + f = newmount(m, um->to, flg, um->spec); | |
| 527 | + *h = f; | |
| 528 | + h = &f->next; | |
| 529 | + } | |
| 530 | + } | |
| 531 | + | |
| 532 | + if(m->mount && order == MREPL) { | |
| 533 | + mountfree(m->mount); | |
| 534 | + m->mount = 0; | |
| 535 | + } | |
| 536 | + | |
| 537 | + if(flag & MCREATE) | |
| 538 | + nm->mflag |= MCREATE; | |
| 539 | + | |
| 540 | + if(m->mount && order == MAFTER) { | |
| 541 | + for(f = m->mount; f->next; f = f->next) | |
| 542 | + ; | |
| 543 | + f->next = nm; | |
| 544 | + } | |
| 545 | + else { | |
| 546 | + for(f = nm; f->next; f = f->next) | |
| 547 | + ; | |
| 548 | + f->next = m->mount; | |
| 549 | + m->mount = nm; | |
| 550 | + } | |
| 551 | + | |
| 552 | + wunlock(&m->lock); | |
| 553 | + poperror(); | |
| 554 | + return nm->mountid; | |
| 555 | +} | |
| 556 | + | |
| 557 | +void | |
| 558 | +cunmount(Chan *mnt, Chan *mounted) | |
| 559 | +{ | |
| 560 | + Pgrp *pg; | |
| 561 | + Mhead *m, **l; | |
| 562 | + Mount *f, **p; | |
| 563 | + | |
| 564 | + if(mnt->umh) /* should not happen */ | |
| 565 | + print("cunmount newp extra umh %p has %p\n", mnt, mnt->umh); | |
| 566 | + | |
| 567 | + /* | |
| 568 | + * It _can_ happen that mounted->umh is non-nil, | |
| 569 | + * because mounted is the result of namec(Aopen) | |
| 570 | + * (see sysfile.c:/^sysunmount). | |
| 571 | + * If we open a union directory, it will have a umh. | |
| 572 | + * Although surprising, this is okay, since the | |
| 573 | + * cclose will take care of freeing the umh. | |
| 574 | + */ | |
| 575 | + | |
| 576 | + pg = up->pgrp; | |
| 577 | + wlock(&pg->ns); | |
| 578 | + | |
| 579 | + l = &MOUNTH(pg, mnt->qid); | |
| 580 | + for(m = *l; m; m = m->hash) { | |
| 581 | + if(eqchan(m->from, mnt, 1)) | |
| 582 | + break; | |
| 583 | + l = &m->hash; | |
| 584 | + } | |
| 585 | + | |
| 586 | + if(m == 0) { | |
| 587 | + wunlock(&pg->ns); | |
| 588 | + error(Eunmount); | |
| 589 | + } | |
| 590 | + | |
| 591 | + wlock(&m->lock); | |
| 592 | + if(mounted == 0) { | |
| 593 | + *l = m->hash; | |
| 594 | + wunlock(&pg->ns); | |
| 595 | + mountfree(m->mount); | |
| 596 | + m->mount = nil; | |
| 597 | + cclose(m->from); | |
| 598 | + wunlock(&m->lock); | |
| 599 | + putmhead(m); | |
| 600 | + return; | |
| 601 | + } | |
| 602 | + | |
| 603 | + p = &m->mount; | |
| 604 | + for(f = *p; f; f = f->next) { | |
| 605 | + /* BUG: Needs to be 2 pass */ | |
| 606 | + if(eqchan(f->to, mounted, 1) || | |
| 607 | + (f->to->mchan && eqchan(f->to->mchan, mounted, 1))) { | |
| 608 | + *p = f->next; | |
| 609 | + f->next = 0; | |
| 610 | + mountfree(f); | |
| 611 | + if(m->mount == nil) { | |
| 612 | + *l = m->hash; | |
| 613 | + cclose(m->from); | |
| 614 | + wunlock(&m->lock); | |
| 615 | + wunlock(&pg->ns); | |
| 616 | + putmhead(m); | |
| 617 | + return; | |
| 618 | + } | |
| 619 | + wunlock(&m->lock); | |
| 620 | + wunlock(&pg->ns); | |
| 621 | + return; | |
| 622 | + } | |
| 623 | + p = &f->next; | |
| 624 | + } | |
| 625 | + wunlock(&m->lock); | |
| 626 | + wunlock(&pg->ns); | |
| 627 | + error(Eunion); | |
| 628 | +} | |
| 629 | + | |
| 630 | +Chan* | |
| 631 | +cclone(Chan *c) | |
| 632 | +{ | |
| 633 | + Chan *nc; | |
| 634 | + Walkqid *wq; | |
| 635 | + | |
| 636 | + wq = devtab[c->type]->walk(c, nil, nil, 0); | |
| 637 | + if(wq == nil) | |
| 638 | + error("clone failed"); | |
| 639 | + nc = wq->clone; | |
| 640 | + free(wq); | |
| 641 | + nc->name = c->name; | |
| 642 | + if(c->name) | |
| 643 | + incref(&c->name->ref); | |
| 644 | + return nc; | |
| 645 | +} | |
| 646 | + | |
| 647 | +int | |
| 648 | +findmount(Chan **cp, Mhead **mp, int type, int dev, Qid qid) | |
| 649 | +{ | |
| 650 | + Pgrp *pg; | |
| 651 | + Mhead *m; | |
| 652 | + | |
| 653 | + pg = up->pgrp; | |
| 654 | + rlock(&pg->ns); | |
| 655 | + for(m = MOUNTH(pg, qid); m; m = m->hash){ | |
| 656 | + rlock(&m->lock); | |
| 657 | +if(m->from == nil){ | |
| 658 | + print("m %p m->from 0\n", m); | |
| 659 | + runlock(&m->lock); | |
| 660 | + continue; | |
| 661 | +} | |
| 662 | + if(eqchantdqid(m->from, type, dev, qid, 1)) { | |
| 663 | + runlock(&pg->ns); | |
| 664 | + if(mp != nil){ | |
| 665 | + incref(&m->ref); | |
| 666 | + if(*mp != nil) | |
| 667 | + putmhead(*mp); | |
| 668 | + *mp = m; | |
| 669 | + } | |
| 670 | + if(*cp != nil) | |
| 671 | + cclose(*cp); | |
| 672 | + incref(&m->mount->to->ref); | |
| 673 | + *cp = m->mount->to; | |
| 674 | + runlock(&m->lock); | |
| 675 | + return 1; | |
| 676 | + } | |
| 677 | + runlock(&m->lock); | |
| 678 | + } | |
| 679 | + | |
| 680 | + runlock(&pg->ns); | |
| 681 | + return 0; | |
| 682 | +} | |
| 683 | + | |
| 684 | +int | |
| 685 | +domount(Chan **cp, Mhead **mp) | |
| 686 | +{ | |
| 687 | + return findmount(cp, mp, (*cp)->type, (*cp)->dev, (*cp)->qid); | |
| 688 | +} | |
| 689 | + | |
| 690 | +Chan* | |
| 691 | +undomount(Chan *c, Cname *name) | |
| 692 | +{ | |
| 693 | + Chan *nc; | |
| 694 | + Pgrp *pg; | |
| 695 | + Mount *t; | |
| 696 | + Mhead **h, **he, *f; | |
| 697 | + | |
| 698 | + pg = up->pgrp; | |
| 699 | + rlock(&pg->ns); | |
| 700 | + if(waserror()) { | |
| 701 | + runlock(&pg->ns); | |
| 702 | + nexterror(); | |
| 703 | + } | |
| 704 | + | |
| 705 | + he = &pg->mnthash[MNTHASH]; | |
| 706 | + for(h = pg->mnthash; h < he; h++) { | |
| 707 | + for(f = *h; f; f = f->hash) { | |
| 708 | + if(strcmp(f->from->name->s, name->s) != 0) | |
| 709 | + continue; | |
| 710 | + for(t = f->mount; t; t = t->next) { | |
| 711 | + if(eqchan(c, t->to, 1)) { | |
| 712 | + /* | |
| 713 | + * We want to come out on the left hand side of the mount | |
| 714 | + * point using the element of the union that we entered on. | |
| 715 | + * To do this, find the element that has a from name of | |
| 716 | + * c->name->s. | |
| 717 | + */ | |
| 718 | + if(strcmp(t->head->from->name->s, name->s) != 0) | |
| 719 | + continue; | |
| 720 | + nc = t->head->from; | |
| 721 | + incref(&nc->ref); | |
| 722 | + cclose(c); | |
| 723 | + c = nc; | |
| 724 | + break; | |
| 725 | + } | |
| 726 | + } | |
| 727 | + } | |
| 728 | + } | |
| 729 | + poperror(); | |
| 730 | + runlock(&pg->ns); | |
| 731 | + return c; | |
| 732 | +} | |
| 733 | + | |
| 734 | +/* | |
| 735 | + * Either walks all the way or not at all. No partial results in *cp. | |
| 736 | + * *nerror is the number of names to display in an error message. | |
| 737 | + */ | |
| 738 | +static char Edoesnotexist[] = "does not exist"; | |
| 739 | +int | |
| 740 | +walk(Chan **cp, char **names, int nnames, int nomount, int *nerror) | |
| 741 | +{ | |
| 742 | + int dev, dotdot, i, n, nhave, ntry, type; | |
| 743 | + Chan *c, *nc; | |
| 744 | + Cname *cname; | |
| 745 | + Mount *f; | |
| 746 | + Mhead *mh, *nmh; | |
| 747 | + Walkqid *wq; | |
| 748 | + | |
| 749 | + c = *cp; | |
| 750 | + incref(&c->ref); | |
| 751 | + cname = c->name; | |
| 752 | + incref(&cname->ref); | |
| 753 | + mh = nil; | |
| 754 | + | |
| 755 | + /* | |
| 756 | + * While we haven't gotten all the way down the path: | |
| 757 | + * 1. step through a mount point, if any | |
| 758 | + * 2. send a walk request for initial dotdot or initial prefix without dotdot | |
| 759 | + * 3. move to the first mountpoint along the way. | |
| 760 | + * 4. repeat. | |
| 761 | + * | |
| 762 | + * An invariant is that each time through the loop, c is on the undomount | |
| 763 | + * side of the mount point, and c's name is cname. | |
| 764 | + */ | |
| 765 | + for(nhave=0; nhave<nnames; nhave+=n){ | |
| 766 | + if((c->qid.type&QTDIR)==0){ | |
| 767 | + if(nerror) | |
| 768 | + *nerror = nhave; | |
| 769 | + cnameclose(cname); | |
| 770 | + cclose(c); | |
| 771 | + strcpy(up->errstr, Enotdir); | |
| 772 | + if(mh != nil) | |
| 773 | +{print("walk 1\n"); | |
| 774 | + putmhead(mh); | |
| 775 | +} | |
| 776 | + return -1; | |
| 777 | + } | |
| 778 | + ntry = nnames - nhave; | |
| 779 | + if(ntry > MAXWELEM) | |
| 780 | + ntry = MAXWELEM; | |
| 781 | + dotdot = 0; | |
| 782 | + for(i=0; i<ntry; i++){ | |
| 783 | + if(isdotdot(names[nhave+i])){ | |
| 784 | + if(i==0) { | |
| 785 | + dotdot = 1; | |
| 786 | + ntry = 1; | |
| 787 | + } else | |
| 788 | + ntry = i; | |
| 789 | + break; | |
| 790 | + } | |
| 791 | + } | |
| 792 | + | |
| 793 | + if(!dotdot && !nomount) | |
| 794 | + domount(&c, &mh); | |
| 795 | + | |
| 796 | + type = c->type; | |
| 797 | + dev = c->dev; | |
| 798 | + | |
| 799 | + if((wq = devtab[type]->walk(c, nil, names+nhave, ntry)) == nil){ | |
| 800 | + /* try a union mount, if any */ | |
| 801 | + if(mh && !nomount){ | |
| 802 | + /* | |
| 803 | + * mh->mount == c, so start at mh->mount->next | |
| 804 | + */ | |
| 805 | + rlock(&mh->lock); | |
| 806 | + for(f = mh->mount->next; f; f = f->next) | |
| 807 | + if((wq = devtab[f->to->type]->walk(f->to, nil, names+nhave, ntry)) != nil) | |
| 808 | + break; | |
| 809 | + runlock(&mh->lock); | |
| 810 | + if(f != nil){ | |
| 811 | + type = f->to->type; | |
| 812 | + dev = f->to->dev; | |
| 813 | + } | |
| 814 | + } | |
| 815 | + if(wq == nil){ | |
| 816 | + cclose(c); | |
| 817 | + cnameclose(cname); | |
| 818 | + if(nerror) | |
| 819 | + *nerror = nhave+1; | |
| 820 | + if(mh != nil) | |
| 821 | + putmhead(mh); | |
| 822 | + return -1; | |
| 823 | + } | |
| 824 | + } | |
| 825 | + | |
| 826 | + nmh = nil; | |
| 827 | + if(dotdot) { | |
| 828 | + assert(wq->nqid == 1); | |
| 829 | + assert(wq->clone != nil); | |
| 830 | + | |
| 831 | + cname = addelem(cname, ".."); | |
| 832 | + nc = undomount(wq->clone, cname); | |
| 833 | + n = 1; | |
| 834 | + } else { | |
| 835 | + nc = nil; | |
| 836 | + if(!nomount) | |
| 837 | + for(i=0; i<wq->nqid && i<ntry-1; i++) | |
| 838 | + if(findmount(&nc, &nmh, type, dev, wq->qid[i])) | |
| 839 | + break; | |
| 840 | + if(nc == nil){ /* no mount points along path */ | |
| 841 | + if(wq->clone == nil){ | |
| 842 | + cclose(c); | |
| 843 | + cnameclose(cname); | |
| 844 | + if(wq->nqid==0 || (wq->qid[wq->nqid-1].type&QTDIR)){ | |
| 845 | + if(nerror) | |
| 846 | + *nerror = nhave+wq->nqid+1; | |
| 847 | + strcpy(up->errstr, Edoesnotexist); | |
| 848 | + }else{ | |
| 849 | + if(nerror) | |
| 850 | + *nerror = nhave+wq->nqid; | |
| 851 | + strcpy(up->errstr, Enotdir); | |
| 852 | + } | |
| 853 | + free(wq); | |
| 854 | + if(mh != nil) | |
| 855 | + putmhead(mh); | |
| 856 | + return -1; | |
| 857 | + } | |
| 858 | + n = wq->nqid; | |
| 859 | + nc = wq->clone; | |
| 860 | + }else{ /* stopped early, at a mount point */ | |
| 861 | + if(wq->clone != nil){ | |
| 862 | + cclose(wq->clone); | |
| 863 | + wq->clone = nil; | |
| 864 | + } | |
| 865 | + n = i+1; | |
| 866 | + } | |
| 867 | + for(i=0; i<n; i++) | |
| 868 | + cname = addelem(cname, names[nhave+i]); | |
| 869 | + } | |
| 870 | + cclose(c); | |
| 871 | + c = nc; | |
| 872 | + putmhead(mh); | |
| 873 | + mh = nmh; | |
| 874 | + free(wq); | |
| 875 | + } | |
| 876 | + | |
| 877 | + putmhead(mh); | |
| 878 | + | |
| 879 | + c = cunique(c); | |
| 880 | + | |
| 881 | + if(c->umh != nil){ //BUG | |
| 882 | + print("walk umh\n"); | |
| 883 | + putmhead(c->umh); | |
| 884 | + c->umh = nil; | |
| 885 | + } | |
| 886 | + | |
| 887 | + cnameclose(c->name); | |
| 888 | + c->name = cname; | |
| 889 | + | |
| 890 | + cclose(*cp); | |
| 891 | + *cp = c; | |
| 892 | + if(nerror) | |
| 893 | + *nerror = 0; | |
| 894 | + return 0; | |
| 895 | +} | |
| 896 | + | |
| 897 | +/* | |
| 898 | + * c is a mounted non-creatable directory. find a creatable one. | |
| 899 | + */ | |
| 900 | +Chan* | |
| 901 | +createdir(Chan *c, Mhead *m) | |
| 902 | +{ | |
| 903 | + Chan *nc; | |
| 904 | + Mount *f; | |
| 905 | + | |
| 906 | + rlock(&m->lock); | |
| 907 | + if(waserror()) { | |
| 908 | + runlock(&m->lock); | |
| 909 | + nexterror(); | |
| 910 | + } | |
| 911 | + for(f = m->mount; f; f = f->next) { | |
| 912 | + if(f->mflag&MCREATE) { | |
| 913 | + nc = cclone(f->to); | |
| 914 | + runlock(&m->lock); | |
| 915 | + poperror(); | |
| 916 | + cclose(c); | |
| 917 | + return nc; | |
| 918 | + } | |
| 919 | + } | |
| 920 | + error(Enocreate); | |
| 921 | + return 0; | |
| 922 | +} | |
| 923 | + | |
| 924 | +void | |
| 925 | +saveregisters(void) | |
| 926 | +{ | |
| 927 | +} | |
| 928 | + | |
| 929 | +/* | |
| 930 | + * In place, rewrite name to compress multiple /, eliminate ., and process .. | |
| 931 | + */ | |
| 932 | +void | |
| 933 | +cleancname(Cname *n) | |
| 934 | +{ | |
| 935 | + char *p; | |
| 936 | + | |
| 937 | + if(n->s[0] == '#'){ | |
| 938 | + p = strchr(n->s, '/'); | |
| 939 | + if(p == nil) | |
| 940 | + return; | |
| 941 | + cleanname(p); | |
| 942 | + | |
| 943 | + /* | |
| 944 | + * The correct name is #i rather than #i/, | |
| 945 | + * but the correct name of #/ is #/. | |
| 946 | + */ | |
| 947 | + if(strcmp(p, "/")==0 && n->s[1] != '/') | |
| 948 | + *p = '\0'; | |
| 949 | + }else | |
| 950 | + cleanname(n->s); | |
| 951 | + n->len = strlen(n->s); | |
| 952 | +} | |
| 953 | + | |
| 954 | +static void | |
| 955 | +growparse(Elemlist *e) | |
| 956 | +{ | |
| 957 | + char **new; | |
| 958 | + int *inew; | |
| 959 | + enum { Delta = 8 }; | |
| 960 | + | |
| 961 | + if(e->nelems % Delta == 0){ | |
| 962 | + new = smalloc((e->nelems+Delta) * sizeof(char*)); | |
| 963 | + memmove(new, e->elems, e->nelems*sizeof(char*)); | |
| 964 | + free(e->elems); | |
| 965 | + e->elems = new; | |
| 966 | + inew = smalloc((e->nelems+Delta+1) * sizeof(int)); | |
| 967 | + memmove(inew, e->off, e->nelems*sizeof(int)); | |
| 968 | + free(e->off); | |
| 969 | + e->off = inew; | |
| 970 | + } | |
| 971 | +} | |
| 972 | + | |
| 973 | +/* | |
| 974 | + * The name is known to be valid. | |
| 975 | + * Copy the name so slashes can be overwritten. | |
| 976 | + * An empty string will set nelem=0. | |
| 977 | + * A path ending in / or /. or /.//./ etc. will have | |
| 978 | + * e.mustbedir = 1, so that we correctly | |
| 979 | + * reject, e.g., "/adm/users/." when /adm/users is a file | |
| 980 | + * rather than a directory. | |
| 981 | + */ | |
| 982 | +static void | |
| 983 | +parsename(char *name, Elemlist *e) | |
| 984 | +{ | |
| 985 | + char *slash; | |
| 986 | + | |
| 987 | + kstrdup(&e->name, name); | |
| 988 | + name = e->name; | |
| 989 | + e->nelems = 0; | |
| 990 | + e->elems = nil; | |
| 991 | + e->off = smalloc(sizeof(int)); | |
| 992 | + e->off[0] = skipslash(name) - name; | |
| 993 | + for(;;){ | |
| 994 | + name = skipslash(name); | |
| 995 | + if(*name=='\0'){ | |
| 996 | + e->mustbedir = 1; | |
| 997 | + break; | |
| 998 | + } | |
| 999 | + growparse(e); | |
| 1000 | + e->elems[e->nelems++] = name; | |
| 1001 | + slash = utfrune(name, '/'); | |
| 1002 | + if(slash == nil){ | |
| 1003 | + e->off[e->nelems] = name+strlen(name) - e->name; | |
| 1004 | + e->mustbedir = 0; | |
| 1005 | + break; | |
| 1006 | + } | |
| 1007 | + e->off[e->nelems] = slash - e->name; | |
| 1008 | + *slash++ = '\0'; | |
| 1009 | + name = slash; | |
| 1010 | + } | |
| 1011 | +} | |
| 1012 | + | |
| 1013 | +void* | |
| 1014 | +memrchr(void *va, int c, long n) | |
| 1015 | +{ | |
| 1016 | + uchar *a, *e; | |
| 1017 | + | |
| 1018 | + a = va; | |
| 1019 | + for(e=a+n-1; e>a; e--) | |
| 1020 | + if(*e == c) | |
| 1021 | + return e; | |
| 1022 | + return nil; | |
| 1023 | +} | |
| 1024 | + | |
| 1025 | +/* | |
| 1026 | + * Turn a name into a channel. | |
| 1027 | + * &name[0] is known to be a valid address. It may be a kernel address. | |
| 1028 | + * | |
| 1029 | + * Opening with amode Aopen, Acreate, or Aremove guarantees | |
| 1030 | + * that the result will be the only reference to that particular fid. | |
| 1031 | + * This is necessary since we might pass the result to | |
| 1032 | + * devtab[]->remove(). | |
| 1033 | + * | |
| 1034 | + * Opening Atodir, Amount, or Aaccess does not guarantee this. | |
| 1035 | + * | |
| 1036 | + * Opening Aaccess can, under certain conditions, return a | |
| 1037 | + * correct Chan* but with an incorrect Cname attached. | |
| 1038 | + * Since the functions that open Aaccess (sysstat, syswstat, sys_stat) | |
| 1039 | + * do not use the Cname*, this avoids an unnecessary clone. | |
| 1040 | + */ | |
| 1041 | +Chan* | |
| 1042 | +namec(char *aname, int amode, int omode, ulong perm) | |
| 1043 | +{ | |
| 1044 | + int n, prefix, len, t, nomount, npath; | |
| 1045 | + Chan *c, *cnew; | |
| 1046 | + Cname *cname; | |
| 1047 | + Elemlist e; | |
| 1048 | + Rune r; | |
| 1049 | + Mhead *m; | |
| 1050 | + char *createerr, tmperrbuf[ERRMAX]; | |
| 1051 | + char *name; | |
| 1052 | + | |
| 1053 | + name = aname; | |
| 1054 | + if(name[0] == '\0') | |
| 1055 | + error("empty file name"); | |
| 1056 | + validname(name, 1); | |
| 1057 | + | |
| 1058 | + /* | |
| 1059 | + * Find the starting off point (the current slash, the root of | |
| 1060 | + * a device tree, or the current dot) as well as the name to | |
| 1061 | + * evaluate starting there. | |
| 1062 | + */ | |
| 1063 | + nomount = 0; | |
| 1064 | + switch(name[0]){ | |
| 1065 | + case '/': | |
| 1066 | + c = up->slash; | |
| 1067 | + incref(&c->ref); | |
| 1068 | + break; | |
| 1069 | + | |
| 1070 | + case '#': | |
| 1071 | + nomount = 1; | |
| 1072 | + up->genbuf[0] = '\0'; | |
| 1073 | + n = 0; | |
| 1074 | + while(*name!='\0' && (*name != '/' || n < 2)){ | |
| 1075 | + if(n >= sizeof(up->genbuf)-1) | |
| 1076 | + error(Efilename); | |
| 1077 | + up->genbuf[n++] = *name++; | |
| 1078 | + } | |
| 1079 | + up->genbuf[n] = '\0'; | |
| 1080 | + /* | |
| 1081 | + * noattach is sandboxing. | |
| 1082 | + * | |
| 1083 | + * the OK exceptions are: | |
| 1084 | + * | it only gives access to pipes you create | |
| 1085 | + * d this process's file descriptors | |
| 1086 | + * e this process's environment | |
| 1087 | + * the iffy exceptions are: | |
| 1088 | + * c time and pid, but also cons and consctl | |
| 1089 | + * p control of your own processes (and unfortunately | |
| 1090 | + * any others left unprotected) | |
| 1091 | + */ | |
| 1092 | + n = chartorune(&r, up->genbuf+1)+1; | |
| 1093 | + /* actually / is caught by parsing earlier */ | |
| 1094 | + if(utfrune("M", r)) | |
| 1095 | + error(Enoattach); | |
| 1096 | + if(up->pgrp->noattach && utfrune("|decp", r)==nil) | |
| 1097 | + error(Enoattach); | |
| 1098 | + t = devno(r, 1); | |
| 1099 | + if(t == -1) | |
| 1100 | + error(Ebadsharp); | |
| 1101 | + c = devtab[t]->attach(up->genbuf+n); | |
| 1102 | + break; | |
| 1103 | + | |
| 1104 | + default: | |
| 1105 | + c = up->dot; | |
| 1106 | + incref(&c->ref); | |
| 1107 | + break; | |
| 1108 | + } | |
| 1109 | + prefix = name - aname; | |
| 1110 | + | |
| 1111 | + e.name = nil; | |
| 1112 | + e.elems = nil; | |
| 1113 | + e.off = nil; | |
| 1114 | + e.nelems = 0; | |
| 1115 | + if(waserror()){ | |
| 1116 | + cclose(c); | |
| 1117 | + free(e.name); | |
| 1118 | + free(e.elems); | |
| 1119 | + free(e.off); | |
| 1120 | +//dumpmount(); | |
| 1121 | + nexterror(); | |
| 1122 | + } | |
| 1123 | + | |
| 1124 | + /* | |
| 1125 | + * Build a list of elements in the path. | |
| 1126 | + */ | |
| 1127 | + parsename(name, &e); | |
| 1128 | + | |
| 1129 | + /* | |
| 1130 | + * On create, .... | |
| 1131 | + */ | |
| 1132 | + if(amode == Acreate){ | |
| 1133 | + /* perm must have DMDIR if last element is / or /. */ | |
| 1134 | + if(e.mustbedir && !(perm&DMDIR)){ | |
| 1135 | + npath = e.nelems; | |
| 1136 | + strcpy(tmperrbuf, "create without DMDIR"); | |
| 1137 | + goto NameError; | |
| 1138 | + } | |
| 1139 | + | |
| 1140 | + /* don't try to walk the last path element just yet. */ | |
| 1141 | + if(e.nelems == 0) | |
| 1142 | + error(Eexist); | |
| 1143 | + e.nelems--; | |
| 1144 | + } | |
| 1145 | + | |
| 1146 | + if(walk(&c, e.elems, e.nelems, nomount, &npath) < 0){ | |
| 1147 | + if(npath < 0 || npath > e.nelems){ | |
| 1148 | + print("namec %s walk error npath=%d\n", aname, npath); | |
| 1149 | + nexterror(); | |
| 1150 | + } | |
| 1151 | + strcpy(tmperrbuf, up->errstr); | |
| 1152 | + NameError: | |
| 1153 | + len = prefix+e.off[npath]; | |
| 1154 | + if(len < ERRMAX/3 || (name=memrchr(aname, '/', len))==nil || name==aname) | |
| 1155 | + snprint(up->genbuf, sizeof up->genbuf, "%.*s", len, aname); | |
| 1156 | + else | |
| 1157 | + snprint(up->genbuf, sizeof up->genbuf, "...%.*s", (int)(len-(name-aname)), name); | |
| 1158 | + snprint(up->errstr, ERRMAX, "%#q %s", up->genbuf, tmperrbuf); | |
| 1159 | + nexterror(); | |
| 1160 | + } | |
| 1161 | + | |
| 1162 | + if(e.mustbedir && !(c->qid.type&QTDIR)){ | |
| 1163 | + npath = e.nelems; | |
| 1164 | + strcpy(tmperrbuf, "not a directory"); | |
| 1165 | + goto NameError; | |
| 1166 | + } | |
| 1167 | + | |
| 1168 | + if(amode == Aopen && (omode&3) == OEXEC && (c->qid.type&QTDIR)){ | |
| 1169 | + npath = e.nelems; | |
| 1170 | + error("cannot exec directory"); | |
| 1171 | + } | |
| 1172 | + | |
| 1173 | + switch(amode){ | |
| 1174 | + case Aaccess: | |
| 1175 | + if(!nomount) | |
| 1176 | + domount(&c, nil); | |
| 1177 | + break; | |
| 1178 | + | |
| 1179 | + case Abind: | |
| 1180 | + m = nil; | |
| 1181 | + if(!nomount) | |
| 1182 | + domount(&c, &m); | |
| 1183 | + if(c->umh != nil) | |
| 1184 | + putmhead(c->umh); | |
| 1185 | + c->umh = m; | |
| 1186 | + break; | |
| 1187 | + | |
| 1188 | + case Aremove: | |
| 1189 | + case Aopen: | |
| 1190 | + Open: | |
| 1191 | + /* save the name; domount might change c */ | |
| 1192 | + cname = c->name; | |
| 1193 | + incref(&cname->ref); | |
| 1194 | + m = nil; | |
| 1195 | + if(!nomount) | |
| 1196 | + domount(&c, &m); | |
| 1197 | + | |
| 1198 | + /* our own copy to open or remove */ | |
| 1199 | + c = cunique(c); | |
| 1200 | + | |
| 1201 | + /* now it's our copy anyway, we can put the name back */ | |
| 1202 | + cnameclose(c->name); | |
| 1203 | + c->name = cname; | |
| 1204 | + | |
| 1205 | + switch(amode){ | |
| 1206 | + case Aremove: | |
| 1207 | + putmhead(m); | |
| 1208 | + break; | |
| 1209 | + | |
| 1210 | + case Aopen: | |
| 1211 | + case Acreate: | |
| 1212 | +if(c->umh != nil){ | |
| 1213 | + print("cunique umh Open\n"); | |
| 1214 | + putmhead(c->umh); | |
| 1215 | + c->umh = nil; | |
| 1216 | +} | |
| 1217 | + | |
| 1218 | + /* only save the mount head if it's a multiple element union */ | |
| 1219 | + if(m && m->mount && m->mount->next) | |
| 1220 | + c->umh = m; | |
| 1221 | + else | |
| 1222 | + putmhead(m); | |
| 1223 | + | |
| 1224 | + /* save registers else error() in open has wrong value of c saved */ | |
| 1225 | + saveregisters(); | |
| 1226 | + | |
| 1227 | + if(omode == OEXEC) | |
| 1228 | + c->flag &= ~CCACHE; | |
| 1229 | + | |
| 1230 | + c = devtab[c->type]->open(c, omode&~OCEXEC); | |
| 1231 | + | |
| 1232 | + if(omode & OCEXEC) | |
| 1233 | + c->flag |= CCEXEC; | |
| 1234 | + if(omode & ORCLOSE) | |
| 1235 | + c->flag |= CRCLOSE; | |
| 1236 | + break; | |
| 1237 | + } | |
| 1238 | + break; | |
| 1239 | + | |
| 1240 | + case Atodir: | |
| 1241 | + /* | |
| 1242 | + * Directories (e.g. for cd) are left before the mount point, | |
| 1243 | + * so one may mount on / or . and see the effect. | |
| 1244 | + */ | |
| 1245 | + if(!(c->qid.type & QTDIR)) | |
| 1246 | + error(Enotdir); | |
| 1247 | + break; | |
| 1248 | + | |
| 1249 | + case Amount: | |
| 1250 | + /* | |
| 1251 | + * When mounting on an already mounted upon directory, | |
| 1252 | + * one wants subsequent mounts to be attached to the | |
| 1253 | + * original directory, not the replacement. Don't domount. | |
| 1254 | + */ | |
| 1255 | + break; | |
| 1256 | + | |
| 1257 | + case Acreate: | |
| 1258 | + /* | |
| 1259 | + * We've already walked all but the last element. | |
| 1260 | + * If the last exists, try to open it OTRUNC. | |
| 1261 | + * If omode&OEXCL is set, just give up. | |
| 1262 | + */ | |
| 1263 | + e.nelems++; | |
| 1264 | + if(walk(&c, e.elems+e.nelems-1, 1, nomount, nil) == 0){ | |
| 1265 | + if(omode&OEXCL) | |
| 1266 | + error(Eexist); | |
| 1267 | + omode |= OTRUNC; | |
| 1268 | + goto Open; | |
| 1269 | + } | |
| 1270 | + | |
| 1271 | + /* | |
| 1272 | + * The semantics of the create(2) system call are that if the | |
| 1273 | + * file exists and can be written, it is to be opened with truncation. | |
| 1274 | + * On the other hand, the create(5) message fails if the file exists. | |
| 1275 | + * If we get two create(2) calls happening simultaneously, | |
| 1276 | + * they might both get here and send create(5) messages, but only | |
| 1277 | + * one of the messages will succeed. To provide the expected create(2) | |
| 1278 | + * semantics, the call with the failed message needs to try the above | |
| 1279 | + * walk again, opening for truncation. This correctly solves the | |
| 1280 | + * create/create race, in the sense that any observable outcome can | |
| 1281 | + * be explained as one happening before the other. | |
| 1282 | + * The create/create race is quite common. For example, it happens | |
| 1283 | + * when two rc subshells simultaneously update the same | |
| 1284 | + * environment variable. | |
| 1285 | + * | |
| 1286 | + * The implementation still admits a create/create/remove race: | |
| 1287 | + * (A) walk to file, fails | |
| 1288 | + * (B) walk to file, fails | |
| 1289 | + * (A) create file, succeeds, returns | |
| 1290 | + * (B) create file, fails | |
| 1291 | + * (A) remove file, succeeds, returns | |
| 1292 | + * (B) walk to file, return failure. | |
| 1293 | + * | |
| 1294 | + * This is hardly as common as the create/create race, and is really | |
| 1295 | + * not too much worse than what might happen if (B) got a hold of a | |
| 1296 | + * file descriptor and then the file was removed -- either way (B) can't do | |
| 1297 | + * anything with the result of the create call. So we don't care about this race. | |
| 1298 | + * | |
| 1299 | + * Applications that care about more fine-grained decision of the races | |
| 1300 | + * can use the OEXCL flag to get at the underlying create(5) semantics; | |
| 1301 | + * by default we provide the common case. | |
| 1302 | + * | |
| 1303 | + * We need to stay behind the mount point in case we | |
| 1304 | + * need to do the first walk again (should the create fail). | |
| 1305 | + * | |
| 1306 | + * We also need to cross the mount point and find the directory | |
| 1307 | + * in the union in which we should be creating. | |
| 1308 | + * | |
| 1309 | + * The channel staying behind is c, the one moving forward is cnew. | |
| 1310 | + */ | |
| 1311 | + m = nil; | |
| 1312 | + cnew = nil; /* is this assignment necessary? */ | |
| 1313 | + if(!waserror()){ /* try create */ | |
| 1314 | + if(!nomount && findmount(&cnew, &m, c->type, c->dev, c->qid)) | |
| 1315 | + cnew = createdir(cnew, m); | |
| 1316 | + else{ | |
| 1317 | + cnew = c; | |
| 1318 | + incref(&cnew->ref); | |
| 1319 | + } | |
| 1320 | + | |
| 1321 | + /* | |
| 1322 | + * We need our own copy of the Chan because we're | |
| 1323 | + * about to send a create, which will move it. Once we have | |
| 1324 | + * our own copy, we can fix the name, which might be wrong | |
| 1325 | + * if findmount gave us a new Chan. | |
| 1326 | + */ | |
| 1327 | + cnew = cunique(cnew); | |
| 1328 | + cnameclose(cnew->name); | |
| 1329 | + cnew->name = c->name; | |
| 1330 | + incref(&cnew->name->ref); | |
| 1331 | + | |
| 1332 | + devtab[cnew->type]->create(cnew, e.elems[e.nelems-1], omode&~(OEXCL|OCEXEC), perm); | |
| 1333 | + poperror(); | |
| 1334 | + if(omode & OCEXEC) | |
| 1335 | + cnew->flag |= CCEXEC; | |
| 1336 | + if(omode & ORCLOSE) | |
| 1337 | + cnew->flag |= CRCLOSE; | |
| 1338 | + if(m) | |
| 1339 | + putmhead(m); | |
| 1340 | + cclose(c); | |
| 1341 | + c = cnew; | |
| 1342 | + c->name = addelem(c->name, e.elems[e.nelems-1]); | |
| 1343 | + break; | |
| 1344 | + }else{ /* create failed */ | |
| 1345 | + cclose(cnew); | |
| 1346 | + if(m) | |
| 1347 | + putmhead(m); | |
| 1348 | + if(omode & OEXCL) | |
| 1349 | + nexterror(); | |
| 1350 | + /* save error */ | |
| 1351 | + createerr = up->errstr; | |
| 1352 | + up->errstr = tmperrbuf; | |
| 1353 | + /* note: we depend that walk does not error */ | |
| 1354 | + if(walk(&c, e.elems+e.nelems-1, 1, nomount, nil) < 0){ | |
| 1355 | + up->errstr = createerr; | |
| 1356 | + error(createerr); /* report true error */ | |
| 1357 | + } | |
| 1358 | + up->errstr = createerr; | |
| 1359 | + omode |= OTRUNC; | |
| 1360 | + goto Open; | |
| 1361 | + } | |
| 1362 | + panic("namec: not reached"); | |
| 1363 | + | |
| 1364 | + default: | |
| 1365 | + panic("unknown namec access %d\n", amode); | |
| 1366 | + } | |
| 1367 | + | |
| 1368 | + poperror(); | |
| 1369 | + | |
| 1370 | + /* place final element in genbuf for e.g. exec */ | |
| 1371 | + if(e.nelems > 0) | |
| 1372 | + kstrcpy(up->genbuf, e.elems[e.nelems-1], sizeof up->genbuf); | |
| 1373 | + else | |
| 1374 | + kstrcpy(up->genbuf, ".", sizeof up->genbuf); | |
| 1375 | + free(e.name); | |
| 1376 | + free(e.elems); | |
| 1377 | + free(e.off); | |
| 1378 | + | |
| 1379 | + return c; | |
| 1380 | +} | |
| 1381 | + | |
| 1382 | +/* | |
| 1383 | + * name is valid. skip leading / and ./ as much as possible | |
| 1384 | + */ | |
| 1385 | +char* | |
| 1386 | +skipslash(char *name) | |
| 1387 | +{ | |
| 1388 | + while(name[0]=='/' || (name[0]=='.' && (name[1]==0 || name[1]=='/'))) | |
| 1389 | + name++; | |
| 1390 | + return name; | |
| 1391 | +} | |
| 1392 | + | |
| 1393 | +char isfrog[256]={ | |
| 1394 | + /*NUL*/ 1, 1, 1, 1, 1, 1, 1, 1, /* 0 */ | |
| 1395 | + /*BKS*/ 1, 1, 1, 1, 1, 1, 1, 1, /* 0x08 */ | |
| 1396 | + /*DLE*/ 1, 1, 1, 1, 1, 1, 1, 1, /* 0x10 */ | |
| 1397 | + /*CAN*/ 1, 1, 1, 1, 1, 1, 1, 1, /* 0x18 */ | |
| 1398 | + 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */ | |
| 1399 | + 0, 0, 0, 0, 0, 0, 0, 1, /* 0x28 (1 is '/', 0x2F) */ | |
| 1400 | + 0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 */ | |
| 1401 | + 0, 0, 0, 0, 0, 0, 0, 0, /* 0x38 */ | |
| 1402 | + 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */ | |
| 1403 | + 0, 0, 0, 0, 0, 0, 0, 0, /* 0x48 */ | |
| 1404 | + 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */ | |
| 1405 | + 0, 0, 0, 0, 0, 0, 0, 0, /* 0x58 */ | |
| 1406 | + 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 */ | |
| 1407 | + 0, 0, 0, 0, 0, 0, 0, 0, /* 0x68 */ | |
| 1408 | + 0, 0, 0, 0, 0, 0, 0, 0, /* 0x70 */ | |
| 1409 | + 0, 0, 0, 0, 0, 0, 0, 1, /* 0x78 (1 is DEL, 0x7F) */ | |
| 1410 | +}; | |
| 1411 | + | |
| 1412 | +/* | |
| 1413 | + * Check that the name | |
| 1414 | + * a) is in valid memory. | |
| 1415 | + * b) is shorter than 2^16 bytes, so it can fit in a 9P string field. | |
| 1416 | + * c) contains no frogs. | |
| 1417 | + * The first byte is known to be addressible by the requester, so the | |
| 1418 | + * routine works for kernel and user memory both. | |
| 1419 | + * The parameter slashok flags whether a slash character is an error | |
| 1420 | + * or a valid character. | |
| 1421 | + */ | |
| 1422 | +void | |
| 1423 | +validname(char *aname, int slashok) | |
| 1424 | +{ | |
| 1425 | + char *p, *ename, *name; | |
| 1426 | + uint t; | |
| 1427 | + int c; | |
| 1428 | + Rune r; | |
| 1429 | + | |
| 1430 | + name = aname; | |
| 1431 | +/* | |
| 1432 | + if(((ulong)name & KZERO) != KZERO) { | |
| 1433 | + p = name; | |
| 1434 | + t = BY2PG-((ulong)p&(BY2PG-1)); | |
| 1435 | + while((ename=vmemchr(p, 0, t)) == nil) { | |
| 1436 | + p += t; | |
| 1437 | + t = BY2PG; | |
| 1438 | + } | |
| 1439 | + }else | |
| 1440 | +*/ | |
| 1441 | + ename = memchr(name, 0, (1<<16)); | |
| 1442 | + | |
| 1443 | + if(ename==nil || ename-name>=(1<<16)) | |
| 1444 | + error("name too long"); | |
| 1445 | + | |
| 1446 | + while(*name){ | |
| 1447 | + /* all characters above '~' are ok */ | |
| 1448 | + c = *(uchar*)name; | |
| 1449 | + if(c >= Runeself) | |
| 1450 | + name += chartorune(&r, name); | |
| 1451 | + else{ | |
| 1452 | + if(isfrog[c]) | |
| 1453 | + if(!slashok || c!='/'){ | |
| 1454 | + snprint(up->genbuf, sizeof(up->genbuf), "%s: %q", Ebadchar, aname); | |
| 1455 | + error(up->genbuf); | |
| 1456 | + } | |
| 1457 | + name++; | |
| 1458 | + } | |
| 1459 | + } | |
| 1460 | +} | |
| 1461 | + | |
| 1462 | +void | |
| 1463 | +isdir(Chan *c) | |
| 1464 | +{ | |
| 1465 | + if(c->qid.type & QTDIR) | |
| 1466 | + return; | |
| 1467 | + error(Enotdir); | |
| 1468 | +} | |
| 1469 | + | |
| 1470 | +/* | |
| 1471 | + * This is necessary because there are many | |
| 1472 | + * pointers to the top of a given mount list: | |
| 1473 | + * | |
| 1474 | + * - the mhead in the namespace hash table | |
| 1475 | + * - the mhead in chans returned from findmount: | |
| 1476 | + * used in namec and then by unionread. | |
| 1477 | + * - the mhead in chans returned from createdir: | |
| 1478 | + * used in the open/create race protect, which is gone. | |
| 1479 | + * | |
| 1480 | + * The RWlock in the Mhead protects the mount list it contains. | |
| 1481 | + * The mount list is deleted when we cunmount. | |
| 1482 | + * The RWlock ensures that nothing is using the mount list at that time. | |
| 1483 | + * | |
| 1484 | + * It is okay to replace c->mh with whatever you want as | |
| 1485 | + * long as you are sure you have a unique reference to it. | |
| 1486 | + * | |
| 1487 | + * This comment might belong somewhere else. | |
| 1488 | + */ | |
| 1489 | +void | |
| 1490 | +putmhead(Mhead *m) | |
| 1491 | +{ | |
| 1492 | + if(m && decref(&m->ref) == 0){ | |
| 1493 | + m->mount = (Mount*)0xCafeBeef; | |
| 1494 | + free(m); | |
| 1495 | + } | |
| 1496 | +} | |
| @@ -0,0 +1,519 @@ | ||
| 1 | +#define KNAMELEN 28 /* max length of name held in kernel */ | |
| 2 | +#define DOMLEN 64 | |
| 3 | + | |
| 4 | +#define BLOCKALIGN 8 | |
| 5 | + | |
| 6 | +typedef struct Alarms Alarms; | |
| 7 | +typedef struct Block Block; | |
| 8 | +typedef struct CSN CSN; | |
| 9 | +typedef struct Chan Chan; | |
| 10 | +typedef struct Cmdbuf Cmdbuf; | |
| 11 | +typedef struct Cmdtab Cmdtab; | |
| 12 | +typedef struct Cname Cname; | |
| 13 | +typedef struct Conf Conf; | |
| 14 | +typedef struct Dev Dev; | |
| 15 | +typedef struct Dirtab Dirtab; | |
| 16 | +typedef struct Edfinterface Edfinterface; | |
| 17 | +typedef struct Egrp Egrp; | |
| 18 | +typedef struct Evalue Evalue; | |
| 19 | +typedef struct Fgrp Fgrp; | |
| 20 | +typedef struct FPsave FPsave; | |
| 21 | +typedef struct DevConf DevConf; | |
| 22 | +typedef struct Label Label; | |
| 23 | +typedef struct List List; | |
| 24 | +typedef struct Log Log; | |
| 25 | +typedef struct Logflag Logflag; | |
| 26 | +typedef struct Mntcache Mntcache; | |
| 27 | +typedef struct Mount Mount; | |
| 28 | +typedef struct Mntrpc Mntrpc; | |
| 29 | +typedef struct Mntwalk Mntwalk; | |
| 30 | +typedef struct Mnt Mnt; | |
| 31 | +typedef struct Mhead Mhead; | |
| 32 | +typedef struct Note Note; | |
| 33 | +typedef struct Page Page; | |
| 34 | +typedef struct Palloc Palloc; | |
| 35 | +typedef struct Perf Perf; | |
| 36 | +typedef struct Pgrps Pgrps; | |
| 37 | +typedef struct PhysUart PhysUart; | |
| 38 | +typedef struct Pgrp Pgrp; | |
| 39 | +typedef struct Physseg Physseg; | |
| 40 | +typedef struct Proc Proc; | |
| 41 | +typedef struct Pte Pte; | |
| 42 | +typedef struct Pthash Pthash; | |
| 43 | +typedef struct Queue Queue; | |
| 44 | +typedef struct Ref Ref; | |
| 45 | +typedef struct Rendez Rendez; | |
| 46 | +typedef struct Rgrp Rgrp; | |
| 47 | +typedef struct RWlock RWlock; | |
| 48 | +typedef struct Schedq Schedq; | |
| 49 | +typedef struct Segment Segment; | |
| 50 | +typedef struct Session Session; | |
| 51 | +typedef struct Task Task; | |
| 52 | +typedef struct Talarm Talarm; | |
| 53 | +typedef struct Timer Timer; | |
| 54 | +typedef struct Uart Uart; | |
| 55 | +typedef struct Ureg Ureg; | |
| 56 | +typedef struct Waitq Waitq; | |
| 57 | +typedef struct Walkqid Walkqid; | |
| 58 | +typedef int Devgen(Chan*, char*, Dirtab*, int, int, Dir*); | |
| 59 | + | |
| 60 | +#include "fcall.h" | |
| 61 | + | |
| 62 | +enum | |
| 63 | +{ | |
| 64 | + SnarfSize = 64*1024, | |
| 65 | +}; | |
| 66 | + | |
| 67 | +struct Conf | |
| 68 | +{ | |
| 69 | + ulong nmach; /* processors */ | |
| 70 | + ulong nproc; /* processes */ | |
| 71 | + ulong monitor; /* has monitor? */ | |
| 72 | + ulong npage0; /* total physical pages of memory */ | |
| 73 | + ulong npage1; /* total physical pages of memory */ | |
| 74 | + ulong npage; /* total physical pages of memory */ | |
| 75 | + ulong upages; /* user page pool */ | |
| 76 | + ulong nimage; /* number of page cache image headers */ | |
| 77 | + ulong nswap; /* number of swap pages */ | |
| 78 | + int nswppo; /* max # of pageouts per segment pass */ | |
| 79 | + ulong base0; /* base of bank 0 */ | |
| 80 | + ulong base1; /* base of bank 1 */ | |
| 81 | + ulong copymode; /* 0 is copy on write, 1 is copy on reference */ | |
| 82 | + ulong ialloc; /* max interrupt time allocation in bytes */ | |
| 83 | + ulong pipeqsize; /* size in bytes of pipe queues */ | |
| 84 | + int nuart; /* number of uart devices */ | |
| 85 | +}; | |
| 86 | + | |
| 87 | +struct Label | |
| 88 | +{ | |
| 89 | + jmp_buf buf; | |
| 90 | +}; | |
| 91 | + | |
| 92 | +struct Ref | |
| 93 | +{ | |
| 94 | + Lock lk; | |
| 95 | + long ref; | |
| 96 | +}; | |
| 97 | + | |
| 98 | +struct Rendez | |
| 99 | +{ | |
| 100 | + Lock lk; | |
| 101 | + Proc *p; | |
| 102 | +}; | |
| 103 | + | |
| 104 | +struct RWlock /* changed from kernel */ | |
| 105 | +{ | |
| 106 | + int readers; | |
| 107 | + Lock lk; | |
| 108 | + QLock x; | |
| 109 | + QLock k; | |
| 110 | +}; | |
| 111 | + | |
| 112 | +struct Talarm | |
| 113 | +{ | |
| 114 | + Lock lk; | |
| 115 | + Proc *list; | |
| 116 | +}; | |
| 117 | + | |
| 118 | +struct Alarms | |
| 119 | +{ | |
| 120 | + QLock lk; | |
| 121 | + Proc *head; | |
| 122 | +}; | |
| 123 | + | |
| 124 | +/* | |
| 125 | + * Access types in namec & channel flags | |
| 126 | + */ | |
| 127 | +enum | |
| 128 | +{ | |
| 129 | + Aaccess, /* as in stat, wstat */ | |
| 130 | + Abind, /* for left-hand-side of bind */ | |
| 131 | + Atodir, /* as in chdir */ | |
| 132 | + Aopen, /* for i/o */ | |
| 133 | + Amount, /* to be mounted or mounted upon */ | |
| 134 | + Acreate, /* is to be created */ | |
| 135 | + Aremove, /* will be removed by caller */ | |
| 136 | + | |
| 137 | + COPEN = 0x0001, /* for i/o */ | |
| 138 | + CMSG = 0x0002, /* the message channel for a mount */ | |
| 139 | +/*rsc CCREATE = 0x0004, /* permits creation if c->mnt */ | |
| 140 | + CCEXEC = 0x0008, /* close on exec */ | |
| 141 | + CFREE = 0x0010, /* not in use */ | |
| 142 | + CRCLOSE = 0x0020, /* remove on close */ | |
| 143 | + CCACHE = 0x0080, /* client cache */ | |
| 144 | +}; | |
| 145 | + | |
| 146 | +/* flag values */ | |
| 147 | +enum | |
| 148 | +{ | |
| 149 | + BINTR = (1<<0), | |
| 150 | + BFREE = (1<<1), | |
| 151 | + Bipck = (1<<2), /* ip checksum */ | |
| 152 | + Budpck = (1<<3), /* udp checksum */ | |
| 153 | + Btcpck = (1<<4), /* tcp checksum */ | |
| 154 | + Bpktck = (1<<5), /* packet checksum */ | |
| 155 | +}; | |
| 156 | + | |
| 157 | +struct Block | |
| 158 | +{ | |
| 159 | + Block* next; | |
| 160 | + Block* list; | |
| 161 | + uchar* rp; /* first unconsumed byte */ | |
| 162 | + uchar* wp; /* first empty byte */ | |
| 163 | + uchar* lim; /* 1 past the end of the buffer */ | |
| 164 | + uchar* base; /* start of the buffer */ | |
| 165 | + void (*free)(Block*); | |
| 166 | + ushort flag; | |
| 167 | + ushort checksum; /* IP checksum of complete packet (minus media header) */ | |
| 168 | +}; | |
| 169 | +#define BLEN(s) ((s)->wp - (s)->rp) | |
| 170 | +#define BALLOC(s) ((s)->lim - (s)->base) | |
| 171 | + | |
| 172 | +struct Chan | |
| 173 | +{ | |
| 174 | + Ref ref; | |
| 175 | + Chan* next; /* allocation */ | |
| 176 | + Chan* link; | |
| 177 | + vlong offset; /* in file */ | |
| 178 | + ushort type; | |
| 179 | + ulong dev; | |
| 180 | + ushort mode; /* read/write */ | |
| 181 | + ushort flag; | |
| 182 | + Qid qid; | |
| 183 | + int fid; /* for devmnt */ | |
| 184 | + ulong iounit; /* chunk size for i/o; 0==default */ | |
| 185 | + Mhead* umh; /* mount point that derived Chan; used in unionread */ | |
| 186 | + Chan* umc; /* channel in union; held for union read */ | |
| 187 | + QLock umqlock; /* serialize unionreads */ | |
| 188 | + int uri; /* union read index */ | |
| 189 | + int dri; /* devdirread index */ | |
| 190 | + ulong mountid; | |
| 191 | + Mntcache *mcp; /* Mount cache pointer */ | |
| 192 | + Mnt *mux; /* Mnt for clients using me for messages */ | |
| 193 | + void* aux; | |
| 194 | + Qid pgrpid; /* for #p/notepg */ | |
| 195 | + ulong mid; /* for ns in devproc */ | |
| 196 | + Chan* mchan; /* channel to mounted server */ | |
| 197 | + Qid mqid; /* qid of root of mount point */ | |
| 198 | + Session*session; | |
| 199 | + Cname *name; | |
| 200 | +}; | |
| 201 | + | |
| 202 | +struct Cname | |
| 203 | +{ | |
| 204 | + Ref ref; | |
| 205 | + int alen; /* allocated length */ | |
| 206 | + int len; /* strlen(s) */ | |
| 207 | + char *s; | |
| 208 | +}; | |
| 209 | + | |
| 210 | +struct Dev | |
| 211 | +{ | |
| 212 | + int dc; | |
| 213 | + char* name; | |
| 214 | + | |
| 215 | + void (*reset)(void); | |
| 216 | + void (*init)(void); | |
| 217 | + void (*shutdown)(void); | |
| 218 | + Chan* (*attach)(char*); | |
| 219 | + Walkqid* (*walk)(Chan*, Chan*, char**, int); | |
| 220 | + int (*stat)(Chan*, uchar*, int); | |
| 221 | + Chan* (*open)(Chan*, int); | |
| 222 | + void (*create)(Chan*, char*, int, ulong); | |
| 223 | + void (*close)(Chan*); | |
| 224 | + long (*read)(Chan*, void*, long, vlong); | |
| 225 | + Block* (*bread)(Chan*, long, ulong); | |
| 226 | + long (*write)(Chan*, void*, long, vlong); | |
| 227 | + long (*bwrite)(Chan*, Block*, ulong); | |
| 228 | + void (*remove)(Chan*); | |
| 229 | + int (*wstat)(Chan*, uchar*, int); | |
| 230 | + void (*power)(int); /* power mgt: power(1) => on, power (0) => off */ | |
| 231 | + int (*config)(int, char*, DevConf*); // returns nil on error | |
| 232 | +}; | |
| 233 | + | |
| 234 | +struct Dirtab | |
| 235 | +{ | |
| 236 | + char name[KNAMELEN]; | |
| 237 | + Qid qid; | |
| 238 | + vlong length; | |
| 239 | + long perm; | |
| 240 | +}; | |
| 241 | + | |
| 242 | +struct Walkqid | |
| 243 | +{ | |
| 244 | + Chan *clone; | |
| 245 | + int nqid; | |
| 246 | + Qid qid[1]; | |
| 247 | +}; | |
| 248 | + | |
| 249 | +enum | |
| 250 | +{ | |
| 251 | + NSMAX = 1000, | |
| 252 | + NSLOG = 7, | |
| 253 | + NSCACHE = (1<<NSLOG), | |
| 254 | +}; | |
| 255 | + | |
| 256 | +struct Mntwalk /* state for /proc/#/ns */ | |
| 257 | +{ | |
| 258 | + int cddone; | |
| 259 | + ulong id; | |
| 260 | + Mhead* mh; | |
| 261 | + Mount* cm; | |
| 262 | +}; | |
| 263 | + | |
| 264 | +struct Mount | |
| 265 | +{ | |
| 266 | + ulong mountid; | |
| 267 | + Mount* next; | |
| 268 | + Mhead* head; | |
| 269 | + Mount* copy; | |
| 270 | + Mount* order; | |
| 271 | + Chan* to; /* channel replacing channel */ | |
| 272 | + int mflag; | |
| 273 | + char *spec; | |
| 274 | +}; | |
| 275 | + | |
| 276 | +struct Mhead | |
| 277 | +{ | |
| 278 | + Ref ref; | |
| 279 | + RWlock lock; | |
| 280 | + Chan* from; /* channel mounted upon */ | |
| 281 | + Mount* mount; /* what's mounted upon it */ | |
| 282 | + Mhead* hash; /* Hash chain */ | |
| 283 | +}; | |
| 284 | + | |
| 285 | +struct Mnt | |
| 286 | +{ | |
| 287 | + Lock lk; | |
| 288 | + /* references are counted using c->ref; channels on this mount point incref(c->mchan) == Mnt.c */ | |
| 289 | + Chan *c; /* Channel to file service */ | |
| 290 | + Proc *rip; /* Reader in progress */ | |
| 291 | + Mntrpc *queue; /* Queue of pending requests on this channel */ | |
| 292 | + ulong id; /* Multiplexer id for channel check */ | |
| 293 | + Mnt *list; /* Free list */ | |
| 294 | + int flags; /* cache */ | |
| 295 | + int msize; /* data + IOHDRSZ */ | |
| 296 | + char *version; /* 9P version */ | |
| 297 | + Queue *q; /* input queue */ | |
| 298 | +}; | |
| 299 | + | |
| 300 | +enum | |
| 301 | +{ | |
| 302 | + NUser, /* note provided externally */ | |
| 303 | + NExit, /* deliver note quietly */ | |
| 304 | + NDebug, /* print debug message */ | |
| 305 | +}; | |
| 306 | + | |
| 307 | +struct Note | |
| 308 | +{ | |
| 309 | + char msg[ERRMAX]; | |
| 310 | + int flag; /* whether system posted it */ | |
| 311 | +}; | |
| 312 | + | |
| 313 | +enum | |
| 314 | +{ | |
| 315 | + RENDLOG = 5, | |
| 316 | + RENDHASH = 1<<RENDLOG, /* Hash to lookup rendezvous tags */ | |
| 317 | + MNTLOG = 5, | |
| 318 | + MNTHASH = 1<<MNTLOG, /* Hash to walk mount table */ | |
| 319 | + NFD = 100, /* per process file descriptors */ | |
| 320 | + PGHLOG = 9, | |
| 321 | + PGHSIZE = 1<<PGHLOG, /* Page hash for image lookup */ | |
| 322 | +}; | |
| 323 | +#define REND(p,s) ((p)->rendhash[(s)&((1<<RENDLOG)-1)]) | |
| 324 | +#define MOUNTH(p,qid) ((p)->mnthash[(qid).path&((1<<MNTLOG)-1)]) | |
| 325 | + | |
| 326 | +struct Pgrp | |
| 327 | +{ | |
| 328 | + Ref ref; /* also used as a lock when mounting */ | |
| 329 | + int noattach; | |
| 330 | + ulong pgrpid; | |
| 331 | + QLock debug; /* single access via devproc.c */ | |
| 332 | + RWlock ns; /* Namespace n read/one write lock */ | |
| 333 | + Mhead *mnthash[MNTHASH]; | |
| 334 | +}; | |
| 335 | + | |
| 336 | +struct Rgrp | |
| 337 | +{ | |
| 338 | + Ref ref; | |
| 339 | + Proc *rendhash[RENDHASH]; /* Rendezvous tag hash */ | |
| 340 | +}; | |
| 341 | + | |
| 342 | +struct Egrp | |
| 343 | +{ | |
| 344 | + Ref ref; | |
| 345 | + RWlock lk; | |
| 346 | + Evalue **ent; | |
| 347 | + int nent; | |
| 348 | + int ment; | |
| 349 | + ulong path; /* qid.path of next Evalue to be allocated */ | |
| 350 | + ulong vers; /* of Egrp */ | |
| 351 | +}; | |
| 352 | + | |
| 353 | +struct Evalue | |
| 354 | +{ | |
| 355 | + char *name; | |
| 356 | + char *value; | |
| 357 | + int len; | |
| 358 | + Evalue *link; | |
| 359 | + Qid qid; | |
| 360 | +}; | |
| 361 | + | |
| 362 | +struct Fgrp | |
| 363 | +{ | |
| 364 | + Ref ref; | |
| 365 | + Chan **fd; | |
| 366 | + int nfd; /* number allocated */ | |
| 367 | + int maxfd; /* highest fd in use */ | |
| 368 | + int exceed; /* debugging */ | |
| 369 | +}; | |
| 370 | + | |
| 371 | +enum | |
| 372 | +{ | |
| 373 | + DELTAFD = 20, /* incremental increase in Fgrp.fd's */ | |
| 374 | + NERR = 20 | |
| 375 | +}; | |
| 376 | + | |
| 377 | +typedef uvlong Ticks; | |
| 378 | + | |
| 379 | +enum | |
| 380 | +{ | |
| 381 | + Running, | |
| 382 | + Rendezvous, | |
| 383 | + Wakeme, | |
| 384 | +}; | |
| 385 | + | |
| 386 | +struct Proc | |
| 387 | +{ | |
| 388 | + uint state; | |
| 389 | + uint mach; | |
| 390 | + | |
| 391 | + ulong pid; | |
| 392 | + ulong parentpid; | |
| 393 | + | |
| 394 | + Pgrp *pgrp; /* Process group for namespace */ | |
| 395 | + Fgrp *fgrp; /* File descriptor group */ | |
| 396 | + Rgrp *rgrp; | |
| 397 | + | |
| 398 | + Lock rlock; /* sync sleep/wakeup with postnote */ | |
| 399 | + Rendez *r; /* rendezvous point slept on */ | |
| 400 | + Rendez sleep; /* place for syssleep/debug */ | |
| 401 | + int notepending; /* note issued but not acted on */ | |
| 402 | + int kp; /* true if a kernel process */ | |
| 403 | + | |
| 404 | + ulong rendtag; /* Tag for rendezvous */ | |
| 405 | + ulong rendval; /* Value for rendezvous */ | |
| 406 | + Proc *rendhash; /* Hash list for tag values */ | |
| 407 | + | |
| 408 | + int nerrlab; | |
| 409 | + Label errlab[NERR]; | |
| 410 | + char user[KNAMELEN]; | |
| 411 | + char *syserrstr; /* last error from a system call, errbuf0 or 1 */ | |
| 412 | + char *errstr; /* reason we're unwinding the error stack, errbuf1 or 0 */ | |
| 413 | + char errbuf0[ERRMAX]; | |
| 414 | + char errbuf1[ERRMAX]; | |
| 415 | + char genbuf[128]; /* buffer used e.g. for last name element from namec */ | |
| 416 | + char text[KNAMELEN]; | |
| 417 | + | |
| 418 | + Chan *slash; | |
| 419 | + Chan *dot; | |
| 420 | + | |
| 421 | + Proc *qnext; | |
| 422 | + | |
| 423 | + void (*fn)(void*); | |
| 424 | + void *arg; | |
| 425 | + | |
| 426 | + char oproc[1024]; /* reserved for os */ | |
| 427 | + | |
| 428 | +}; | |
| 429 | + | |
| 430 | +enum | |
| 431 | +{ | |
| 432 | + PRINTSIZE = 256, | |
| 433 | + MAXCRYPT = 127, | |
| 434 | + NUMSIZE = 12, /* size of formatted number */ | |
| 435 | + MB = (1024*1024), | |
| 436 | + READSTR = 1000, /* temporary buffer size for device reads */ | |
| 437 | +}; | |
| 438 | + | |
| 439 | +extern char* conffile; | |
| 440 | +extern int cpuserver; | |
| 441 | +extern Dev* devtab[]; | |
| 442 | +extern char *eve; | |
| 443 | +extern char hostdomain[]; | |
| 444 | +extern uchar initcode[]; | |
| 445 | +extern Queue* kbdq; | |
| 446 | +extern Queue* kprintoq; | |
| 447 | +extern Ref noteidalloc; | |
| 448 | +extern Palloc palloc; | |
| 449 | +extern Queue *serialoq; | |
| 450 | +extern char* statename[]; | |
| 451 | +extern int nsyscall; | |
| 452 | +extern char *sysname; | |
| 453 | +extern uint qiomaxatomic; | |
| 454 | +extern Conf conf; | |
| 455 | +enum | |
| 456 | +{ | |
| 457 | + LRESPROF = 3, | |
| 458 | +}; | |
| 459 | + | |
| 460 | +/* | |
| 461 | + * action log | |
| 462 | + */ | |
| 463 | +struct Log { | |
| 464 | + Lock lk; | |
| 465 | + int opens; | |
| 466 | + char* buf; | |
| 467 | + char *end; | |
| 468 | + char *rptr; | |
| 469 | + int len; | |
| 470 | + int nlog; | |
| 471 | + int minread; | |
| 472 | + | |
| 473 | + int logmask; /* mask of things to debug */ | |
| 474 | + | |
| 475 | + QLock readq; | |
| 476 | + Rendez readr; | |
| 477 | +}; | |
| 478 | + | |
| 479 | +struct Logflag { | |
| 480 | + char* name; | |
| 481 | + int mask; | |
| 482 | +}; | |
| 483 | + | |
| 484 | +enum | |
| 485 | +{ | |
| 486 | + NCMDFIELD = 128 | |
| 487 | +}; | |
| 488 | + | |
| 489 | +struct Cmdbuf | |
| 490 | +{ | |
| 491 | + char *buf; | |
| 492 | + char **f; | |
| 493 | + int nf; | |
| 494 | +}; | |
| 495 | + | |
| 496 | +struct Cmdtab | |
| 497 | +{ | |
| 498 | + int index; /* used by client to switch on result */ | |
| 499 | + char *cmd; /* command name */ | |
| 500 | + int narg; /* expected #args; 0 ==> variadic */ | |
| 501 | +}; | |
| 502 | + | |
| 503 | +/* queue state bits, Qmsg, Qcoalesce, and Qkick can be set in qopen */ | |
| 504 | +enum | |
| 505 | +{ | |
| 506 | + /* Queue.state */ | |
| 507 | + Qstarve = (1<<0), /* consumer starved */ | |
| 508 | + Qmsg = (1<<1), /* message stream */ | |
| 509 | + Qclosed = (1<<2), /* queue has been closed/hungup */ | |
| 510 | + Qflow = (1<<3), /* producer flow controlled */ | |
| 511 | + Qcoalesce = (1<<4), /* coallesce packets on read */ | |
| 512 | + Qkick = (1<<5), /* always call the kick routine after qwrite */ | |
| 513 | +}; | |
| 514 | + | |
| 515 | +#define DEVDOTDOT -1 | |
| 516 | + | |
| 517 | +extern Proc *_getproc(void); | |
| 518 | +extern void _setproc(Proc*); | |
| 519 | +#define up (_getproc()) | |
| @@ -0,0 +1,31 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +Proc *up; | |
| 8 | +Conf conf = | |
| 9 | +{ | |
| 10 | + 1, | |
| 11 | + 100, | |
| 12 | + 0, | |
| 13 | + 1024*1024*1024, | |
| 14 | + 1024*1024*1024, | |
| 15 | + 1024*1024*1024, | |
| 16 | + 1024*1024*1024, | |
| 17 | + 1024*1024*1024, | |
| 18 | + 1024*1024*1024, | |
| 19 | + 1024*1024*1024, | |
| 20 | + 1024*1024*1024, | |
| 21 | + 1024*1024*1024, | |
| 22 | + 1024*1024*1024, | |
| 23 | + 1024*1024*1024, | |
| 24 | + 1024*1024*1024, | |
| 25 | + 0, | |
| 26 | +}; | |
| 27 | + | |
| 28 | +char *eve = "eve"; | |
| 29 | +ulong kerndate; | |
| 30 | +int cpuserver; | |
| 31 | +char hostdomain[] = "drawterm.net"; | |
| @@ -0,0 +1,468 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +extern ulong kerndate; | |
| 8 | + | |
| 9 | +void | |
| 10 | +mkqid(Qid *q, vlong path, ulong vers, int type) | |
| 11 | +{ | |
| 12 | + q->type = type; | |
| 13 | + q->vers = vers; | |
| 14 | + q->path = path; | |
| 15 | +} | |
| 16 | + | |
| 17 | +int | |
| 18 | +devno(int c, int user) | |
| 19 | +{ | |
| 20 | + int i; | |
| 21 | + | |
| 22 | + for(i = 0; devtab[i] != nil; i++) { | |
| 23 | + if(devtab[i]->dc == c) | |
| 24 | + return i; | |
| 25 | + } | |
| 26 | + if(user == 0) | |
| 27 | + panic("devno %C 0x%ux", c, c); | |
| 28 | + | |
| 29 | + return -1; | |
| 30 | +} | |
| 31 | + | |
| 32 | +void | |
| 33 | +devdir(Chan *c, Qid qid, char *n, vlong length, char *user, long perm, Dir *db) | |
| 34 | +{ | |
| 35 | + db->name = n; | |
| 36 | + if(c->flag&CMSG) | |
| 37 | + qid.type |= QTMOUNT; | |
| 38 | + db->qid = qid; | |
| 39 | + db->type = devtab[c->type]->dc; | |
| 40 | + db->dev = c->dev; | |
| 41 | + db->mode = perm; | |
| 42 | + db->mode |= qid.type << 24; | |
| 43 | + db->atime = seconds(); | |
| 44 | + db->mtime = kerndate; | |
| 45 | + db->length = length; | |
| 46 | + db->uid = user; | |
| 47 | + db->gid = eve; | |
| 48 | + db->muid = user; | |
| 49 | +} | |
| 50 | + | |
| 51 | +/* | |
| 52 | + * (here, Devgen is the prototype; devgen is the function in dev.c.) | |
| 53 | + * | |
| 54 | + * a Devgen is expected to return the directory entry for ".." | |
| 55 | + * if you pass it s==DEVDOTDOT (-1). otherwise... | |
| 56 | + * | |
| 57 | + * there are two contradictory rules. | |
| 58 | + * | |
| 59 | + * (i) if c is a directory, a Devgen is expected to list its children | |
| 60 | + * as you iterate s. | |
| 61 | + * | |
| 62 | + * (ii) whether or not c is a directory, a Devgen is expected to list | |
| 63 | + * its siblings as you iterate s. | |
| 64 | + * | |
| 65 | + * devgen always returns the list of children in the root | |
| 66 | + * directory. thus it follows (i) when c is the root and (ii) otherwise. | |
| 67 | + * many other Devgens follow (i) when c is a directory and (ii) otherwise. | |
| 68 | + * | |
| 69 | + * devwalk assumes (i). it knows that devgen breaks (i) | |
| 70 | + * for children that are themselves directories, and explicitly catches them. | |
| 71 | + * | |
| 72 | + * devstat assumes (ii). if the Devgen in question follows (i) | |
| 73 | + * for this particular c, devstat will not find the necessary info. | |
| 74 | + * with our particular Devgen functions, this happens only for | |
| 75 | + * directories, so devstat makes something up, assuming | |
| 76 | + * c->name, c->qid, eve, DMDIR|0555. | |
| 77 | + * | |
| 78 | + * devdirread assumes (i). the callers have to make sure | |
| 79 | + * that the Devgen satisfies (i) for the chan being read. | |
| 80 | + */ | |
| 81 | +/* | |
| 82 | + * the zeroth element of the table MUST be the directory itself for .. | |
| 83 | +*/ | |
| 84 | +int | |
| 85 | +devgen(Chan *c, char *name, Dirtab *tab, int ntab, int i, Dir *dp) | |
| 86 | +{ | |
| 87 | + if(tab == 0) | |
| 88 | + return -1; | |
| 89 | + if(i == DEVDOTDOT){ | |
| 90 | + /* nothing */ | |
| 91 | + }else if(name){ | |
| 92 | + for(i=1; i<ntab; i++) | |
| 93 | + if(strcmp(tab[i].name, name) == 0) | |
| 94 | + break; | |
| 95 | + if(i==ntab) | |
| 96 | + return -1; | |
| 97 | + tab += i; | |
| 98 | + }else{ | |
| 99 | + /* skip over the first element, that for . itself */ | |
| 100 | + i++; | |
| 101 | + if(i >= ntab) | |
| 102 | + return -1; | |
| 103 | + tab += i; | |
| 104 | + } | |
| 105 | + devdir(c, tab->qid, tab->name, tab->length, eve, tab->perm, dp); | |
| 106 | + return 1; | |
| 107 | +} | |
| 108 | + | |
| 109 | +void | |
| 110 | +devreset(void) | |
| 111 | +{ | |
| 112 | +} | |
| 113 | + | |
| 114 | +void | |
| 115 | +devinit(void) | |
| 116 | +{ | |
| 117 | +} | |
| 118 | + | |
| 119 | +void | |
| 120 | +devshutdown(void) | |
| 121 | +{ | |
| 122 | +} | |
| 123 | + | |
| 124 | +Chan* | |
| 125 | +devattach(int tc, char *spec) | |
| 126 | +{ | |
| 127 | + Chan *c; | |
| 128 | + char *buf; | |
| 129 | + | |
| 130 | + c = newchan(); | |
| 131 | + mkqid(&c->qid, 0, 0, QTDIR); | |
| 132 | + c->type = devno(tc, 0); | |
| 133 | + if(spec == nil) | |
| 134 | + spec = ""; | |
| 135 | + buf = smalloc(4+strlen(spec)+1); | |
| 136 | + sprint(buf, "#%C%s", tc, spec); | |
| 137 | + c->name = newcname(buf); | |
| 138 | + free(buf); | |
| 139 | + return c; | |
| 140 | +} | |
| 141 | + | |
| 142 | + | |
| 143 | +Chan* | |
| 144 | +devclone(Chan *c) | |
| 145 | +{ | |
| 146 | + Chan *nc; | |
| 147 | + | |
| 148 | + if(c->flag & COPEN) | |
| 149 | + panic("clone of open file type %C\n", devtab[c->type]->dc); | |
| 150 | + | |
| 151 | + nc = newchan(); | |
| 152 | + | |
| 153 | + nc->type = c->type; | |
| 154 | + nc->dev = c->dev; | |
| 155 | + nc->mode = c->mode; | |
| 156 | + nc->qid = c->qid; | |
| 157 | + nc->offset = c->offset; | |
| 158 | + nc->umh = nil; | |
| 159 | + nc->mountid = c->mountid; | |
| 160 | + nc->aux = c->aux; | |
| 161 | + nc->pgrpid = c->pgrpid; | |
| 162 | + nc->mid = c->mid; | |
| 163 | + nc->mqid = c->mqid; | |
| 164 | + nc->mcp = c->mcp; | |
| 165 | + return nc; | |
| 166 | +} | |
| 167 | + | |
| 168 | +Walkqid* | |
| 169 | +devwalk(Chan *c, Chan *nc, char **name, int nname, Dirtab *tab, int ntab, Devgen *gen) | |
| 170 | +{ | |
| 171 | + int i, j, alloc; | |
| 172 | + Walkqid *wq; | |
| 173 | + char *n; | |
| 174 | + Dir dir; | |
| 175 | + | |
| 176 | + if(nname > 0) | |
| 177 | + isdir(c); | |
| 178 | + | |
| 179 | + alloc = 0; | |
| 180 | + wq = smalloc(sizeof(Walkqid)+(nname-1)*sizeof(Qid)); | |
| 181 | + if(waserror()){ | |
| 182 | + if(alloc && wq->clone!=nil) | |
| 183 | + cclose(wq->clone); | |
| 184 | + free(wq); | |
| 185 | + return nil; | |
| 186 | + } | |
| 187 | + if(nc == nil){ | |
| 188 | + nc = devclone(c); | |
| 189 | + nc->type = 0; /* device doesn't know about this channel yet */ | |
| 190 | + alloc = 1; | |
| 191 | + } | |
| 192 | + wq->clone = nc; | |
| 193 | + | |
| 194 | + for(j=0; j<nname; j++){ | |
| 195 | + if(!(nc->qid.type&QTDIR)){ | |
| 196 | + if(j==0) | |
| 197 | + error(Enotdir); | |
| 198 | + goto Done; | |
| 199 | + } | |
| 200 | + n = name[j]; | |
| 201 | + if(strcmp(n, ".") == 0){ | |
| 202 | + Accept: | |
| 203 | + wq->qid[wq->nqid++] = nc->qid; | |
| 204 | + continue; | |
| 205 | + } | |
| 206 | + if(strcmp(n, "..") == 0){ | |
| 207 | + if((*gen)(nc, nil, tab, ntab, DEVDOTDOT, &dir) != 1){ | |
| 208 | + print("devgen walk .. in dev%s %llux broken\n", | |
| 209 | + devtab[nc->type]->name, nc->qid.path); | |
| 210 | + error("broken devgen"); | |
| 211 | + } | |
| 212 | + nc->qid = dir.qid; | |
| 213 | + goto Accept; | |
| 214 | + } | |
| 215 | + /* | |
| 216 | + * Ugly problem: If we're using devgen, make sure we're | |
| 217 | + * walking the directory itself, represented by the first | |
| 218 | + * entry in the table, and not trying to step into a sub- | |
| 219 | + * directory of the table, e.g. /net/net. Devgen itself | |
| 220 | + * should take care of the problem, but it doesn't have | |
| 221 | + * the necessary information (that we're doing a walk). | |
| 222 | + */ | |
| 223 | + if(gen==devgen && nc->qid.path!=tab[0].qid.path) | |
| 224 | + goto Notfound; | |
| 225 | + for(i=0;; i++) { | |
| 226 | + switch((*gen)(nc, n, tab, ntab, i, &dir)){ | |
| 227 | + case -1: | |
| 228 | + Notfound: | |
| 229 | + if(j == 0) | |
| 230 | + error(Enonexist); | |
| 231 | + kstrcpy(up->errstr, Enonexist, ERRMAX); | |
| 232 | + goto Done; | |
| 233 | + case 0: | |
| 234 | + continue; | |
| 235 | + case 1: | |
| 236 | + if(strcmp(n, dir.name) == 0){ | |
| 237 | + nc->qid = dir.qid; | |
| 238 | + goto Accept; | |
| 239 | + } | |
| 240 | + continue; | |
| 241 | + } | |
| 242 | + } | |
| 243 | + } | |
| 244 | + /* | |
| 245 | + * We processed at least one name, so will return some data. | |
| 246 | + * If we didn't process all nname entries succesfully, we drop | |
| 247 | + * the cloned channel and return just the Qids of the walks. | |
| 248 | + */ | |
| 249 | +Done: | |
| 250 | + poperror(); | |
| 251 | + if(wq->nqid < nname){ | |
| 252 | + if(alloc) | |
| 253 | + cclose(wq->clone); | |
| 254 | + wq->clone = nil; | |
| 255 | + }else if(wq->clone){ | |
| 256 | + /* attach cloned channel to same device */ | |
| 257 | + wq->clone->type = c->type; | |
| 258 | + } | |
| 259 | + return wq; | |
| 260 | +} | |
| 261 | + | |
| 262 | +int | |
| 263 | +devstat(Chan *c, uchar *db, int n, Dirtab *tab, int ntab, Devgen *gen) | |
| 264 | +{ | |
| 265 | + int i; | |
| 266 | + Dir dir; | |
| 267 | + char *p, *elem; | |
| 268 | + | |
| 269 | + for(i=0;; i++) | |
| 270 | + switch((*gen)(c, nil, tab, ntab, i, &dir)){ | |
| 271 | + case -1: | |
| 272 | + if(c->qid.type & QTDIR){ | |
| 273 | + if(c->name == nil) | |
| 274 | + elem = "???"; | |
| 275 | + else if(strcmp(c->name->s, "/") == 0) | |
| 276 | + elem = "/"; | |
| 277 | + else | |
| 278 | + for(elem=p=c->name->s; *p; p++) | |
| 279 | + if(*p == '/') | |
| 280 | + elem = p+1; | |
| 281 | + devdir(c, c->qid, elem, 0, eve, DMDIR|0555, &dir); | |
| 282 | + n = convD2M(&dir, db, n); | |
| 283 | + if(n == 0) | |
| 284 | + error(Ebadarg); | |
| 285 | + return n; | |
| 286 | + } | |
| 287 | + print("devstat %C %llux\n", devtab[c->type]->dc, c->qid.path); | |
| 288 | + | |
| 289 | + error(Enonexist); | |
| 290 | + case 0: | |
| 291 | + break; | |
| 292 | + case 1: | |
| 293 | + if(c->qid.path == dir.qid.path) { | |
| 294 | + if(c->flag&CMSG) | |
| 295 | + dir.mode |= DMMOUNT; | |
| 296 | + n = convD2M(&dir, db, n); | |
| 297 | + if(n == 0) | |
| 298 | + error(Ebadarg); | |
| 299 | + return n; | |
| 300 | + } | |
| 301 | + break; | |
| 302 | + } | |
| 303 | + error(Egreg); /* not reached? */ | |
| 304 | + return -1; | |
| 305 | +} | |
| 306 | + | |
| 307 | +long | |
| 308 | +devdirread(Chan *c, char *d, long n, Dirtab *tab, int ntab, Devgen *gen) | |
| 309 | +{ | |
| 310 | + long m, dsz; | |
| 311 | + struct{ | |
| 312 | + Dir d; | |
| 313 | + char slop[100]; | |
| 314 | + }dir; | |
| 315 | + | |
| 316 | + for(m=0; m<n; c->dri++) { | |
| 317 | + switch((*gen)(c, nil, tab, ntab, c->dri, &dir.d)){ | |
| 318 | + case -1: | |
| 319 | + return m; | |
| 320 | + | |
| 321 | + case 0: | |
| 322 | + break; | |
| 323 | + | |
| 324 | + case 1: | |
| 325 | + dsz = convD2M(&dir.d, (uchar*)d, n-m); | |
| 326 | + if(dsz <= BIT16SZ){ /* <= not < because this isn't stat; read is stuck */ | |
| 327 | + if(m == 0) | |
| 328 | + error(Eshort); | |
| 329 | + return m; | |
| 330 | + } | |
| 331 | + m += dsz; | |
| 332 | + d += dsz; | |
| 333 | + break; | |
| 334 | + } | |
| 335 | + } | |
| 336 | + | |
| 337 | + return m; | |
| 338 | +} | |
| 339 | + | |
| 340 | +/* | |
| 341 | + * error(Eperm) if open permission not granted for up->user. | |
| 342 | + */ | |
| 343 | +void | |
| 344 | +devpermcheck(char *fileuid, ulong perm, int omode) | |
| 345 | +{ | |
| 346 | + ulong t; | |
| 347 | + static int access[] = { 0400, 0200, 0600, 0100 }; | |
| 348 | + | |
| 349 | + if(strcmp(up->user, fileuid) == 0) | |
| 350 | + perm <<= 0; | |
| 351 | + else | |
| 352 | + if(strcmp(up->user, eve) == 0) | |
| 353 | + perm <<= 3; | |
| 354 | + else | |
| 355 | + perm <<= 6; | |
| 356 | + | |
| 357 | + t = access[omode&3]; | |
| 358 | + if((t&perm) != t) | |
| 359 | + error(Eperm); | |
| 360 | +} | |
| 361 | + | |
| 362 | +Chan* | |
| 363 | +devopen(Chan *c, int omode, Dirtab *tab, int ntab, Devgen *gen) | |
| 364 | +{ | |
| 365 | + int i; | |
| 366 | + Dir dir; | |
| 367 | + | |
| 368 | + for(i=0;; i++) { | |
| 369 | + switch((*gen)(c, nil, tab, ntab, i, &dir)){ | |
| 370 | + case -1: | |
| 371 | + goto Return; | |
| 372 | + case 0: | |
| 373 | + break; | |
| 374 | + case 1: | |
| 375 | + if(c->qid.path == dir.qid.path) { | |
| 376 | + devpermcheck(dir.uid, dir.mode, omode); | |
| 377 | + goto Return; | |
| 378 | + } | |
| 379 | + break; | |
| 380 | + } | |
| 381 | + } | |
| 382 | +Return: | |
| 383 | + c->offset = 0; | |
| 384 | + if((c->qid.type&QTDIR) && omode!=OREAD) | |
| 385 | + error(Eperm); | |
| 386 | + c->mode = openmode(omode); | |
| 387 | + c->flag |= COPEN; | |
| 388 | + return c; | |
| 389 | +} | |
| 390 | + | |
| 391 | +void | |
| 392 | +devcreate(Chan *c, char *name, int mode, ulong perm) | |
| 393 | +{ | |
| 394 | + USED(c); | |
| 395 | + USED(name); | |
| 396 | + USED(mode); | |
| 397 | + USED(perm); | |
| 398 | + | |
| 399 | + error(Eperm); | |
| 400 | +} | |
| 401 | + | |
| 402 | +Block* | |
| 403 | +devbread(Chan *c, long n, ulong offset) | |
| 404 | +{ | |
| 405 | + Block *bp; | |
| 406 | + | |
| 407 | + bp = allocb(n); | |
| 408 | + if(bp == 0) | |
| 409 | + error(Enomem); | |
| 410 | + if(waserror()) { | |
| 411 | + freeb(bp); | |
| 412 | + nexterror(); | |
| 413 | + } | |
| 414 | + bp->wp += devtab[c->type]->read(c, bp->wp, n, offset); | |
| 415 | + poperror(); | |
| 416 | + return bp; | |
| 417 | +} | |
| 418 | + | |
| 419 | +long | |
| 420 | +devbwrite(Chan *c, Block *bp, ulong offset) | |
| 421 | +{ | |
| 422 | + long n; | |
| 423 | + | |
| 424 | + if(waserror()) { | |
| 425 | + freeb(bp); | |
| 426 | + nexterror(); | |
| 427 | + } | |
| 428 | + n = devtab[c->type]->write(c, bp->rp, BLEN(bp), offset); | |
| 429 | + poperror(); | |
| 430 | + freeb(bp); | |
| 431 | + | |
| 432 | + return n; | |
| 433 | +} | |
| 434 | + | |
| 435 | +void | |
| 436 | +devremove(Chan *c) | |
| 437 | +{ | |
| 438 | + USED(c); | |
| 439 | + error(Eperm); | |
| 440 | +} | |
| 441 | + | |
| 442 | +int | |
| 443 | +devwstat(Chan *c, uchar *a, int n) | |
| 444 | +{ | |
| 445 | + USED(c); | |
| 446 | + USED(a); | |
| 447 | + USED(n); | |
| 448 | + | |
| 449 | + error(Eperm); | |
| 450 | + return 0; | |
| 451 | +} | |
| 452 | + | |
| 453 | +void | |
| 454 | +devpower(int a) | |
| 455 | +{ | |
| 456 | + USED(a); | |
| 457 | + error(Eperm); | |
| 458 | +} | |
| 459 | + | |
| 460 | +int | |
| 461 | +devconfig(int a, char *b, DevConf *c) | |
| 462 | +{ | |
| 463 | + USED(a); | |
| 464 | + USED(b); | |
| 465 | + USED(c); | |
| 466 | + error(Eperm); | |
| 467 | + return 0; | |
| 468 | +} | |
| @@ -0,0 +1,1238 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +#include "keyboard.h" | |
| 8 | + | |
| 9 | +void (*consdebug)(void) = nil; | |
| 10 | +void (*screenputs)(char*, int) = nil; | |
| 11 | + | |
| 12 | +Queue* kbdq; /* unprocessed console input */ | |
| 13 | +Queue* lineq; /* processed console input */ | |
| 14 | +Queue* serialoq; /* serial console output */ | |
| 15 | +Queue* kprintoq; /* console output, for /dev/kprint */ | |
| 16 | +ulong kprintinuse; /* test and set whether /dev/kprint is open */ | |
| 17 | +int iprintscreenputs = 0; | |
| 18 | + | |
| 19 | +int panicking; | |
| 20 | + | |
| 21 | +struct | |
| 22 | +{ | |
| 23 | + int exiting; | |
| 24 | + int machs; | |
| 25 | +} active; | |
| 26 | + | |
| 27 | +static struct | |
| 28 | +{ | |
| 29 | + QLock lk; | |
| 30 | + | |
| 31 | + int raw; /* true if we shouldn't process input */ | |
| 32 | + int ctl; /* number of opens to the control file */ | |
| 33 | + int x; /* index into line */ | |
| 34 | + char line[1024]; /* current input line */ | |
| 35 | + | |
| 36 | + int count; | |
| 37 | + int ctlpoff; | |
| 38 | + | |
| 39 | + /* a place to save up characters at interrupt time before dumping them in the queue */ | |
| 40 | + Lock lockputc; | |
| 41 | + char istage[1024]; | |
| 42 | + char *iw; | |
| 43 | + char *ir; | |
| 44 | + char *ie; | |
| 45 | +} kbd = { | |
| 46 | + { 0 }, | |
| 47 | + 0, | |
| 48 | + 0, | |
| 49 | + 0, | |
| 50 | + { 0 }, | |
| 51 | + 0, | |
| 52 | + 0, | |
| 53 | + { 0 }, | |
| 54 | + { 0 }, | |
| 55 | + kbd.istage, | |
| 56 | + kbd.istage, | |
| 57 | + kbd.istage + sizeof(kbd.istage), | |
| 58 | +}; | |
| 59 | + | |
| 60 | +char *sysname; | |
| 61 | +vlong fasthz; | |
| 62 | + | |
| 63 | +static void seedrand(void); | |
| 64 | +static int readtime(ulong, char*, int); | |
| 65 | +static int readbintime(char*, int); | |
| 66 | +static int writetime(char*, int); | |
| 67 | +static int writebintime(char*, int); | |
| 68 | + | |
| 69 | +enum | |
| 70 | +{ | |
| 71 | + CMreboot, | |
| 72 | + CMpanic, | |
| 73 | +}; | |
| 74 | + | |
| 75 | +Cmdtab rebootmsg[] = | |
| 76 | +{ | |
| 77 | + CMreboot, "reboot", 0, | |
| 78 | + CMpanic, "panic", 0, | |
| 79 | +}; | |
| 80 | + | |
| 81 | +int | |
| 82 | +return0(void *v) | |
| 83 | +{ | |
| 84 | + return 0; | |
| 85 | +} | |
| 86 | + | |
| 87 | +void | |
| 88 | +printinit(void) | |
| 89 | +{ | |
| 90 | + lineq = qopen(2*1024, 0, nil, nil); | |
| 91 | + if(lineq == nil) | |
| 92 | + panic("printinit"); | |
| 93 | + qnoblock(lineq, 1); | |
| 94 | + | |
| 95 | + kbdq = qopen(4*1024, 0, 0, 0); | |
| 96 | + if(kbdq == nil) | |
| 97 | + panic("kbdinit"); | |
| 98 | + qnoblock(kbdq, 1); | |
| 99 | +} | |
| 100 | + | |
| 101 | +int | |
| 102 | +consactive(void) | |
| 103 | +{ | |
| 104 | + if(serialoq) | |
| 105 | + return qlen(serialoq) > 0; | |
| 106 | + return 0; | |
| 107 | +} | |
| 108 | + | |
| 109 | +void | |
| 110 | +prflush(void) | |
| 111 | +{ | |
| 112 | +/* | |
| 113 | + ulong now; | |
| 114 | + | |
| 115 | + now = m->ticks; | |
| 116 | + while(consactive()) | |
| 117 | + if(m->ticks - now >= HZ) | |
| 118 | + break; | |
| 119 | +*/ | |
| 120 | +} | |
| 121 | + | |
| 122 | +/* | |
| 123 | + * Print a string on the console. Convert \n to \r\n for serial | |
| 124 | + * line consoles. Locking of the queues is left up to the screen | |
| 125 | + * or uart code. Multi-line messages to serial consoles may get | |
| 126 | + * interspersed with other messages. | |
| 127 | + */ | |
| 128 | +static void | |
| 129 | +putstrn0(char *str, int n, int usewrite) | |
| 130 | +{ | |
| 131 | + int m; | |
| 132 | + char *t; | |
| 133 | + | |
| 134 | + /* | |
| 135 | + * if someone is reading /dev/kprint, | |
| 136 | + * put the message there. | |
| 137 | + * if not and there's an attached bit mapped display, | |
| 138 | + * put the message there. | |
| 139 | + * | |
| 140 | + * if there's a serial line being used as a console, | |
| 141 | + * put the message there. | |
| 142 | + */ | |
| 143 | + if(kprintoq != nil && !qisclosed(kprintoq)){ | |
| 144 | + if(usewrite) | |
| 145 | + qwrite(kprintoq, str, n); | |
| 146 | + else | |
| 147 | + qiwrite(kprintoq, str, n); | |
| 148 | + }else if(screenputs != nil) | |
| 149 | + screenputs(str, n); | |
| 150 | + | |
| 151 | + if(serialoq == nil){ | |
| 152 | + uartputs(str, n); | |
| 153 | + return; | |
| 154 | + } | |
| 155 | + | |
| 156 | + while(n > 0) { | |
| 157 | + t = memchr(str, '\n', n); | |
| 158 | + if(t && !kbd.raw) { | |
| 159 | + m = t-str; | |
| 160 | + if(usewrite){ | |
| 161 | + qwrite(serialoq, str, m); | |
| 162 | + qwrite(serialoq, "\r\n", 2); | |
| 163 | + } else { | |
| 164 | + qiwrite(serialoq, str, m); | |
| 165 | + qiwrite(serialoq, "\r\n", 2); | |
| 166 | + } | |
| 167 | + n -= m+1; | |
| 168 | + str = t+1; | |
| 169 | + } else { | |
| 170 | + if(usewrite) | |
| 171 | + qwrite(serialoq, str, n); | |
| 172 | + else | |
| 173 | + qiwrite(serialoq, str, n); | |
| 174 | + break; | |
| 175 | + } | |
| 176 | + } | |
| 177 | +} | |
| 178 | + | |
| 179 | +void | |
| 180 | +putstrn(char *str, int n) | |
| 181 | +{ | |
| 182 | + putstrn0(str, n, 0); | |
| 183 | +} | |
| 184 | + | |
| 185 | +int noprint; | |
| 186 | + | |
| 187 | +int | |
| 188 | +print(char *fmt, ...) | |
| 189 | +{ | |
| 190 | + int n; | |
| 191 | + va_list arg; | |
| 192 | + char buf[PRINTSIZE]; | |
| 193 | + | |
| 194 | + if(noprint) | |
| 195 | + return -1; | |
| 196 | + | |
| 197 | + va_start(arg, fmt); | |
| 198 | + n = vseprint(buf, buf+sizeof(buf), fmt, arg) - buf; | |
| 199 | + va_end(arg); | |
| 200 | + putstrn(buf, n); | |
| 201 | + | |
| 202 | + return n; | |
| 203 | +} | |
| 204 | + | |
| 205 | +int | |
| 206 | +iprint(char *fmt, ...) | |
| 207 | +{ | |
| 208 | + int n, s; | |
| 209 | + va_list arg; | |
| 210 | + char buf[PRINTSIZE]; | |
| 211 | + | |
| 212 | + s = splhi(); | |
| 213 | + va_start(arg, fmt); | |
| 214 | + n = vseprint(buf, buf+sizeof(buf), fmt, arg) - buf; | |
| 215 | + va_end(arg); | |
| 216 | + if(screenputs != nil && iprintscreenputs) | |
| 217 | + screenputs(buf, n); | |
| 218 | + uartputs(buf, n); | |
| 219 | + splx(s); | |
| 220 | + | |
| 221 | + return n; | |
| 222 | +} | |
| 223 | + | |
| 224 | +void | |
| 225 | +panic(char *fmt, ...) | |
| 226 | +{ | |
| 227 | + int n; | |
| 228 | + va_list arg; | |
| 229 | + char buf[PRINTSIZE]; | |
| 230 | + | |
| 231 | + kprintoq = nil; /* don't try to write to /dev/kprint */ | |
| 232 | + | |
| 233 | + if(panicking) | |
| 234 | + for(;;); | |
| 235 | + panicking = 1; | |
| 236 | + | |
| 237 | + splhi(); | |
| 238 | + strcpy(buf, "panic: "); | |
| 239 | + va_start(arg, fmt); | |
| 240 | + n = vseprint(buf+strlen(buf), buf+sizeof(buf), fmt, arg) - buf; | |
| 241 | + va_end(arg); | |
| 242 | + buf[n] = '\n'; | |
| 243 | + uartputs(buf, n+1); | |
| 244 | + if(consdebug) | |
| 245 | + (*consdebug)(); | |
| 246 | + spllo(); | |
| 247 | + prflush(); | |
| 248 | + putstrn(buf, n+1); | |
| 249 | + dumpstack(); | |
| 250 | + | |
| 251 | + exit(1); | |
| 252 | +} | |
| 253 | + | |
| 254 | +int | |
| 255 | +pprint(char *fmt, ...) | |
| 256 | +{ | |
| 257 | + int n; | |
| 258 | + Chan *c; | |
| 259 | + va_list arg; | |
| 260 | + char buf[2*PRINTSIZE]; | |
| 261 | + | |
| 262 | + if(up == nil || up->fgrp == nil) | |
| 263 | + return 0; | |
| 264 | + | |
| 265 | + c = up->fgrp->fd[2]; | |
| 266 | + if(c==0 || (c->mode!=OWRITE && c->mode!=ORDWR)) | |
| 267 | + return 0; | |
| 268 | + n = sprint(buf, "%s %lud: ", up->text, up->pid); | |
| 269 | + va_start(arg, fmt); | |
| 270 | + n = vseprint(buf+n, buf+sizeof(buf), fmt, arg) - buf; | |
| 271 | + va_end(arg); | |
| 272 | + | |
| 273 | + if(waserror()) | |
| 274 | + return 0; | |
| 275 | + devtab[c->type]->write(c, buf, n, c->offset); | |
| 276 | + poperror(); | |
| 277 | + | |
| 278 | + lock(&c->ref.lk); | |
| 279 | + c->offset += n; | |
| 280 | + unlock(&c->ref.lk); | |
| 281 | + | |
| 282 | + return n; | |
| 283 | +} | |
| 284 | + | |
| 285 | +static void | |
| 286 | +echoscreen(char *buf, int n) | |
| 287 | +{ | |
| 288 | + char *e, *p; | |
| 289 | + char ebuf[128]; | |
| 290 | + int x; | |
| 291 | + | |
| 292 | + p = ebuf; | |
| 293 | + e = ebuf + sizeof(ebuf) - 4; | |
| 294 | + while(n-- > 0){ | |
| 295 | + if(p >= e){ | |
| 296 | + screenputs(ebuf, p - ebuf); | |
| 297 | + p = ebuf; | |
| 298 | + } | |
| 299 | + x = *buf++; | |
| 300 | + if(x == 0x15){ | |
| 301 | + *p++ = '^'; | |
| 302 | + *p++ = 'U'; | |
| 303 | + *p++ = '\n'; | |
| 304 | + } else | |
| 305 | + *p++ = x; | |
| 306 | + } | |
| 307 | + if(p != ebuf) | |
| 308 | + screenputs(ebuf, p - ebuf); | |
| 309 | +} | |
| 310 | + | |
| 311 | +static void | |
| 312 | +echoserialoq(char *buf, int n) | |
| 313 | +{ | |
| 314 | + char *e, *p; | |
| 315 | + char ebuf[128]; | |
| 316 | + int x; | |
| 317 | + | |
| 318 | + p = ebuf; | |
| 319 | + e = ebuf + sizeof(ebuf) - 4; | |
| 320 | + while(n-- > 0){ | |
| 321 | + if(p >= e){ | |
| 322 | + qiwrite(serialoq, ebuf, p - ebuf); | |
| 323 | + p = ebuf; | |
| 324 | + } | |
| 325 | + x = *buf++; | |
| 326 | + if(x == '\n'){ | |
| 327 | + *p++ = '\r'; | |
| 328 | + *p++ = '\n'; | |
| 329 | + } else if(x == 0x15){ | |
| 330 | + *p++ = '^'; | |
| 331 | + *p++ = 'U'; | |
| 332 | + *p++ = '\n'; | |
| 333 | + } else | |
| 334 | + *p++ = x; | |
| 335 | + } | |
| 336 | + if(p != ebuf) | |
| 337 | + qiwrite(serialoq, ebuf, p - ebuf); | |
| 338 | +} | |
| 339 | + | |
| 340 | +static void | |
| 341 | +echo(char *buf, int n) | |
| 342 | +{ | |
| 343 | + static int ctrlt, pid; | |
| 344 | + extern ulong etext; | |
| 345 | + int x; | |
| 346 | + char *e, *p; | |
| 347 | + | |
| 348 | + e = buf+n; | |
| 349 | + for(p = buf; p < e; p++){ | |
| 350 | + switch(*p){ | |
| 351 | + case 0x10: /* ^P */ | |
| 352 | + if(cpuserver && !kbd.ctlpoff){ | |
| 353 | + active.exiting = 1; | |
| 354 | + return; | |
| 355 | + } | |
| 356 | + break; | |
| 357 | + case 0x14: /* ^T */ | |
| 358 | + ctrlt++; | |
| 359 | + if(ctrlt > 2) | |
| 360 | + ctrlt = 2; | |
| 361 | + continue; | |
| 362 | + } | |
| 363 | + | |
| 364 | + if(ctrlt != 2) | |
| 365 | + continue; | |
| 366 | + | |
| 367 | + /* ^T escapes */ | |
| 368 | + ctrlt = 0; | |
| 369 | + switch(*p){ | |
| 370 | + case 'S': | |
| 371 | + x = splhi(); | |
| 372 | + dumpstack(); | |
| 373 | + procdump(); | |
| 374 | + splx(x); | |
| 375 | + return; | |
| 376 | + case 's': | |
| 377 | + dumpstack(); | |
| 378 | + return; | |
| 379 | + case 'x': | |
| 380 | + xsummary(); | |
| 381 | + ixsummary(); | |
| 382 | + mallocsummary(); | |
| 383 | + pagersummary(); | |
| 384 | + return; | |
| 385 | + case 'd': | |
| 386 | + if(consdebug == nil) | |
| 387 | + consdebug = rdb; | |
| 388 | + else | |
| 389 | + consdebug = nil; | |
| 390 | + print("consdebug now 0x%p\n", consdebug); | |
| 391 | + return; | |
| 392 | + case 'D': | |
| 393 | + if(consdebug == nil) | |
| 394 | + consdebug = rdb; | |
| 395 | + consdebug(); | |
| 396 | + return; | |
| 397 | + case 'p': | |
| 398 | + x = spllo(); | |
| 399 | + procdump(); | |
| 400 | + splx(x); | |
| 401 | + return; | |
| 402 | + case 'q': | |
| 403 | + scheddump(); | |
| 404 | + return; | |
| 405 | + case 'k': | |
| 406 | + killbig(); | |
| 407 | + return; | |
| 408 | + case 'r': | |
| 409 | + exit(0); | |
| 410 | + return; | |
| 411 | + } | |
| 412 | + } | |
| 413 | + | |
| 414 | + qproduce(kbdq, buf, n); | |
| 415 | + if(kbd.raw) | |
| 416 | + return; | |
| 417 | + if(screenputs != nil) | |
| 418 | + echoscreen(buf, n); | |
| 419 | + if(serialoq) | |
| 420 | + echoserialoq(buf, n); | |
| 421 | +} | |
| 422 | + | |
| 423 | +/* | |
| 424 | + * Called by a uart interrupt for console input. | |
| 425 | + * | |
| 426 | + * turn '\r' into '\n' before putting it into the queue. | |
| 427 | + */ | |
| 428 | +int | |
| 429 | +kbdcr2nl(Queue *q, int ch) | |
| 430 | +{ | |
| 431 | + char *next; | |
| 432 | + | |
| 433 | + USED(q); | |
| 434 | + ilock(&kbd.lockputc); /* just a mutex */ | |
| 435 | + if(ch == '\r' && !kbd.raw) | |
| 436 | + ch = '\n'; | |
| 437 | + next = kbd.iw+1; | |
| 438 | + if(next >= kbd.ie) | |
| 439 | + next = kbd.istage; | |
| 440 | + if(next != kbd.ir){ | |
| 441 | + *kbd.iw = ch; | |
| 442 | + kbd.iw = next; | |
| 443 | + } | |
| 444 | + iunlock(&kbd.lockputc); | |
| 445 | + return 0; | |
| 446 | +} | |
| 447 | +static | |
| 448 | +void | |
| 449 | +_kbdputc(int c) | |
| 450 | +{ | |
| 451 | + Rune r; | |
| 452 | + char buf[UTFmax]; | |
| 453 | + int n; | |
| 454 | + | |
| 455 | + r = c; | |
| 456 | + n = runetochar(buf, &r); | |
| 457 | + if(n == 0) | |
| 458 | + return; | |
| 459 | + echo(buf, n); | |
| 460 | +// kbd.c = r; | |
| 461 | +// qproduce(kbdq, buf, n); | |
| 462 | +} | |
| 463 | + | |
| 464 | +/* _kbdputc, but with compose translation */ | |
| 465 | +int | |
| 466 | +kbdputc(Queue *q, int c) | |
| 467 | +{ | |
| 468 | + int i; | |
| 469 | + static int collecting, nk; | |
| 470 | + static Rune kc[5]; | |
| 471 | + | |
| 472 | + if(c == Kalt){ | |
| 473 | + collecting = 1; | |
| 474 | + nk = 0; | |
| 475 | + return; | |
| 476 | + } | |
| 477 | + | |
| 478 | + if(!collecting){ | |
| 479 | + _kbdputc(c); | |
| 480 | + return; | |
| 481 | + } | |
| 482 | + | |
| 483 | + kc[nk++] = c; | |
| 484 | + c = latin1(kc, nk); | |
| 485 | + if(c < -1) /* need more keystrokes */ | |
| 486 | + return; | |
| 487 | + if(c != -1) /* valid sequence */ | |
| 488 | + _kbdputc(c); | |
| 489 | + else | |
| 490 | + for(i=0; i<nk; i++) | |
| 491 | + _kbdputc(kc[i]); | |
| 492 | + nk = 0; | |
| 493 | + collecting = 0; | |
| 494 | + | |
| 495 | + return 0; | |
| 496 | +} | |
| 497 | + | |
| 498 | + | |
| 499 | +enum{ | |
| 500 | + Qdir, | |
| 501 | + Qbintime, | |
| 502 | + Qcons, | |
| 503 | + Qconsctl, | |
| 504 | + Qcpunote, | |
| 505 | + Qcputime, | |
| 506 | + Qdrivers, | |
| 507 | + Qkprint, | |
| 508 | + Qhostdomain, | |
| 509 | + Qhostowner, | |
| 510 | + Qnull, | |
| 511 | + Qosversion, | |
| 512 | + Qpgrpid, | |
| 513 | + Qpid, | |
| 514 | + Qppid, | |
| 515 | + Qrandom, | |
| 516 | + Qreboot, | |
| 517 | + Qsecstore, | |
| 518 | + Qsnarf, | |
| 519 | + Qswap, | |
| 520 | + Qsysname, | |
| 521 | + Qsysstat, | |
| 522 | + Qtime, | |
| 523 | + Quser, | |
| 524 | + Qzero, | |
| 525 | +}; | |
| 526 | + | |
| 527 | +enum | |
| 528 | +{ | |
| 529 | + VLNUMSIZE= 22, | |
| 530 | +}; | |
| 531 | + | |
| 532 | +static Dirtab consdir[]={ | |
| 533 | + ".", {Qdir, 0, QTDIR}, 0, DMDIR|0555, | |
| 534 | + "bintime", {Qbintime}, 24, 0664, | |
| 535 | + "cons", {Qcons}, 0, 0660, | |
| 536 | + "consctl", {Qconsctl}, 0, 0220, | |
| 537 | + "cpunote", {Qcpunote}, 0, 0444, | |
| 538 | + "cputime", {Qcputime}, 6*NUMSIZE, 0444, | |
| 539 | + "drivers", {Qdrivers}, 0, 0444, | |
| 540 | + "hostdomain", {Qhostdomain}, DOMLEN, 0664, | |
| 541 | + "hostowner", {Qhostowner}, 0, 0664, | |
| 542 | + "kprint", {Qkprint, 0, QTEXCL}, 0, DMEXCL|0440, | |
| 543 | + "null", {Qnull}, 0, 0666, | |
| 544 | + "osversion", {Qosversion}, 0, 0444, | |
| 545 | + "pgrpid", {Qpgrpid}, NUMSIZE, 0444, | |
| 546 | + "pid", {Qpid}, NUMSIZE, 0444, | |
| 547 | + "ppid", {Qppid}, NUMSIZE, 0444, | |
| 548 | + "random", {Qrandom}, 0, 0444, | |
| 549 | + "reboot", {Qreboot}, 0, 0664, | |
| 550 | + "secstore", {Qsecstore}, 0, 0666, | |
| 551 | + "snarf", {Qsnarf}, 0, 0666, | |
| 552 | + "swap", {Qswap}, 0, 0664, | |
| 553 | + "sysname", {Qsysname}, 0, 0664, | |
| 554 | + "sysstat", {Qsysstat}, 0, 0666, | |
| 555 | + "time", {Qtime}, NUMSIZE+3*VLNUMSIZE, 0664, | |
| 556 | + "user", {Quser}, 0, 0666, | |
| 557 | + "zero", {Qzero}, 0, 0444, | |
| 558 | +}; | |
| 559 | + | |
| 560 | +char secstorebuf[65536]; | |
| 561 | +Dirtab *secstoretab = &consdir[Qsecstore]; | |
| 562 | +Dirtab *snarftab = &consdir[Qsnarf]; | |
| 563 | + | |
| 564 | +int | |
| 565 | +readnum(ulong off, char *buf, ulong n, ulong val, int size) | |
| 566 | +{ | |
| 567 | + char tmp[64]; | |
| 568 | + | |
| 569 | + snprint(tmp, sizeof(tmp), "%*.0lud", size-1, val); | |
| 570 | + tmp[size-1] = ' '; | |
| 571 | + if(off >= size) | |
| 572 | + return 0; | |
| 573 | + if(off+n > size) | |
| 574 | + n = size-off; | |
| 575 | + memmove(buf, tmp+off, n); | |
| 576 | + return n; | |
| 577 | +} | |
| 578 | + | |
| 579 | +int | |
| 580 | +readstr(ulong off, char *buf, ulong n, char *str) | |
| 581 | +{ | |
| 582 | + int size; | |
| 583 | + | |
| 584 | + size = strlen(str); | |
| 585 | + if(off >= size) | |
| 586 | + return 0; | |
| 587 | + if(off+n > size) | |
| 588 | + n = size-off; | |
| 589 | + memmove(buf, str+off, n); | |
| 590 | + return n; | |
| 591 | +} | |
| 592 | + | |
| 593 | +static void | |
| 594 | +consinit(void) | |
| 595 | +{ | |
| 596 | + todinit(); | |
| 597 | + randominit(); | |
| 598 | + /* | |
| 599 | + * at 115200 baud, the 1024 char buffer takes 56 ms to process, | |
| 600 | + * processing it every 22 ms should be fine | |
| 601 | + */ | |
| 602 | +/* addclock0link(kbdputcclock, 22); */ | |
| 603 | +} | |
| 604 | + | |
| 605 | +static Chan* | |
| 606 | +consattach(char *spec) | |
| 607 | +{ | |
| 608 | + return devattach('c', spec); | |
| 609 | +} | |
| 610 | + | |
| 611 | +static Walkqid* | |
| 612 | +conswalk(Chan *c, Chan *nc, char **name, int nname) | |
| 613 | +{ | |
| 614 | + return devwalk(c, nc, name,nname, consdir, nelem(consdir), devgen); | |
| 615 | +} | |
| 616 | + | |
| 617 | +static int | |
| 618 | +consstat(Chan *c, uchar *dp, int n) | |
| 619 | +{ | |
| 620 | + return devstat(c, dp, n, consdir, nelem(consdir), devgen); | |
| 621 | +} | |
| 622 | + | |
| 623 | +static Chan* | |
| 624 | +consopen(Chan *c, int omode) | |
| 625 | +{ | |
| 626 | + c->aux = nil; | |
| 627 | + c = devopen(c, omode, consdir, nelem(consdir), devgen); | |
| 628 | + switch((ulong)c->qid.path){ | |
| 629 | + case Qconsctl: | |
| 630 | + qlock(&kbd.lk); | |
| 631 | + kbd.ctl++; | |
| 632 | + qunlock(&kbd.lk); | |
| 633 | + break; | |
| 634 | + | |
| 635 | + case Qkprint: | |
| 636 | + if(tas(&kprintinuse) != 0){ | |
| 637 | + c->flag &= ~COPEN; | |
| 638 | + error(Einuse); | |
| 639 | + } | |
| 640 | + if(kprintoq == nil){ | |
| 641 | + kprintoq = qopen(8*1024, Qcoalesce, 0, 0); | |
| 642 | + if(kprintoq == nil){ | |
| 643 | + c->flag &= ~COPEN; | |
| 644 | + error(Enomem); | |
| 645 | + } | |
| 646 | + qnoblock(kprintoq, 1); | |
| 647 | + }else | |
| 648 | + qreopen(kprintoq); | |
| 649 | + c->iounit = qiomaxatomic; | |
| 650 | + break; | |
| 651 | + | |
| 652 | + case Qsecstore: | |
| 653 | + if(omode == ORDWR) | |
| 654 | + error(Eperm); | |
| 655 | + if(omode != OREAD) | |
| 656 | + memset(secstorebuf, 0, sizeof secstorebuf); | |
| 657 | + break; | |
| 658 | + | |
| 659 | + case Qsnarf: | |
| 660 | + if(omode == ORDWR) | |
| 661 | + error(Eperm); | |
| 662 | + if(omode == OREAD) | |
| 663 | + c->aux = strdup(""); | |
| 664 | + else | |
| 665 | + c->aux = mallocz(SnarfSize, 1); | |
| 666 | + break; | |
| 667 | + } | |
| 668 | + return c; | |
| 669 | +} | |
| 670 | + | |
| 671 | +static void | |
| 672 | +consclose(Chan *c) | |
| 673 | +{ | |
| 674 | + switch((ulong)c->qid.path){ | |
| 675 | + /* last close of control file turns off raw */ | |
| 676 | + case Qconsctl: | |
| 677 | + if(c->flag&COPEN){ | |
| 678 | + qlock(&kbd.lk); | |
| 679 | + if(--kbd.ctl == 0) | |
| 680 | + kbd.raw = 0; | |
| 681 | + qunlock(&kbd.lk); | |
| 682 | + } | |
| 683 | + break; | |
| 684 | + | |
| 685 | + /* close of kprint allows other opens */ | |
| 686 | + case Qkprint: | |
| 687 | + if(c->flag & COPEN){ | |
| 688 | + kprintinuse = 0; | |
| 689 | + qhangup(kprintoq, nil); | |
| 690 | + } | |
| 691 | + break; | |
| 692 | + | |
| 693 | + case Qsnarf: | |
| 694 | + if(c->mode == OWRITE) | |
| 695 | + clipwrite(c->aux); | |
| 696 | + free(c->aux); | |
| 697 | + break; | |
| 698 | + } | |
| 699 | +} | |
| 700 | + | |
| 701 | +static long | |
| 702 | +consread(Chan *c, void *buf, long n, vlong off) | |
| 703 | +{ | |
| 704 | + ulong l; | |
| 705 | + char *b, *bp; | |
| 706 | + char tmp[128]; /* must be >= 6*NUMSIZE */ | |
| 707 | + char *cbuf = buf; | |
| 708 | + int ch, i, k, id, eol; | |
| 709 | + vlong offset = off; | |
| 710 | + | |
| 711 | + if(n <= 0) | |
| 712 | + return n; | |
| 713 | + switch((ulong)c->qid.path){ | |
| 714 | + case Qdir: | |
| 715 | + return devdirread(c, buf, n, consdir, nelem(consdir), devgen); | |
| 716 | + | |
| 717 | + case Qcons: | |
| 718 | + qlock(&kbd.lk); | |
| 719 | + if(waserror()) { | |
| 720 | + qunlock(&kbd.lk); | |
| 721 | + nexterror(); | |
| 722 | + } | |
| 723 | + if(kbd.raw) { | |
| 724 | + if(qcanread(lineq)) | |
| 725 | + n = qread(lineq, buf, n); | |
| 726 | + else { | |
| 727 | + /* read as much as possible */ | |
| 728 | + do { | |
| 729 | + i = qread(kbdq, cbuf, n); | |
| 730 | + cbuf += i; | |
| 731 | + n -= i; | |
| 732 | + } while (n>0 && qcanread(kbdq)); | |
| 733 | + n = cbuf - (char*)buf; | |
| 734 | + } | |
| 735 | + } else { | |
| 736 | + while(!qcanread(lineq)) { | |
| 737 | + qread(kbdq, &kbd.line[kbd.x], 1); | |
| 738 | + ch = kbd.line[kbd.x]; | |
| 739 | + eol = 0; | |
| 740 | + switch(ch){ | |
| 741 | + case '\b': | |
| 742 | + if(kbd.x) | |
| 743 | + kbd.x--; | |
| 744 | + break; | |
| 745 | + case 0x15: | |
| 746 | + kbd.x = 0; | |
| 747 | + break; | |
| 748 | + case '\n': | |
| 749 | + case 0x04: | |
| 750 | + eol = 1; | |
| 751 | + default: | |
| 752 | + kbd.line[kbd.x++] = ch; | |
| 753 | + break; | |
| 754 | + } | |
| 755 | + if(kbd.x == sizeof(kbd.line) || eol){ | |
| 756 | + if(ch == 0x04) | |
| 757 | + kbd.x--; | |
| 758 | + qwrite(lineq, kbd.line, kbd.x); | |
| 759 | + kbd.x = 0; | |
| 760 | + } | |
| 761 | + } | |
| 762 | + n = qread(lineq, buf, n); | |
| 763 | + } | |
| 764 | + qunlock(&kbd.lk); | |
| 765 | + poperror(); | |
| 766 | + return n; | |
| 767 | + | |
| 768 | + case Qcpunote: | |
| 769 | + sleep(&up->sleep, return0, nil); | |
| 770 | + | |
| 771 | + case Qcputime: | |
| 772 | + return 0; | |
| 773 | + | |
| 774 | + case Qkprint: | |
| 775 | + return qread(kprintoq, buf, n); | |
| 776 | + | |
| 777 | + case Qpgrpid: | |
| 778 | + return readnum((ulong)offset, buf, n, up->pgrp->pgrpid, NUMSIZE); | |
| 779 | + | |
| 780 | + case Qpid: | |
| 781 | + return readnum((ulong)offset, buf, n, up->pid, NUMSIZE); | |
| 782 | + | |
| 783 | + case Qppid: | |
| 784 | + return readnum((ulong)offset, buf, n, up->parentpid, NUMSIZE); | |
| 785 | + | |
| 786 | + case Qtime: | |
| 787 | + return readtime((ulong)offset, buf, n); | |
| 788 | + | |
| 789 | + case Qbintime: | |
| 790 | + return readbintime(buf, n); | |
| 791 | + | |
| 792 | + case Qhostowner: | |
| 793 | + return readstr((ulong)offset, buf, n, eve); | |
| 794 | + | |
| 795 | + case Qhostdomain: | |
| 796 | + return readstr((ulong)offset, buf, n, hostdomain); | |
| 797 | + | |
| 798 | + case Quser: | |
| 799 | + return readstr((ulong)offset, buf, n, up->user); | |
| 800 | + | |
| 801 | + case Qnull: | |
| 802 | + return 0; | |
| 803 | + | |
| 804 | + case Qsnarf: | |
| 805 | + if(offset == 0){ | |
| 806 | + free(c->aux); | |
| 807 | + c->aux = clipread(); | |
| 808 | + } | |
| 809 | + if(c->aux == nil) | |
| 810 | + return 0; | |
| 811 | + return readstr(offset, buf, n, c->aux); | |
| 812 | + | |
| 813 | + case Qsecstore: | |
| 814 | + return readstr(offset, buf, n, secstorebuf); | |
| 815 | + | |
| 816 | + case Qsysstat: | |
| 817 | + return 0; | |
| 818 | + | |
| 819 | + case Qswap: | |
| 820 | + return 0; | |
| 821 | + | |
| 822 | + case Qsysname: | |
| 823 | + if(sysname == nil) | |
| 824 | + return 0; | |
| 825 | + return readstr((ulong)offset, buf, n, sysname); | |
| 826 | + | |
| 827 | + case Qrandom: | |
| 828 | + return randomread(buf, n); | |
| 829 | + | |
| 830 | + case Qdrivers: | |
| 831 | + b = malloc(READSTR); | |
| 832 | + if(b == nil) | |
| 833 | + error(Enomem); | |
| 834 | + n = 0; | |
| 835 | + for(i = 0; devtab[i] != nil; i++) | |
| 836 | + n += snprint(b+n, READSTR-n, "#%C %s\n", devtab[i]->dc, devtab[i]->name); | |
| 837 | + if(waserror()){ | |
| 838 | + free(b); | |
| 839 | + nexterror(); | |
| 840 | + } | |
| 841 | + n = readstr((ulong)offset, buf, n, b); | |
| 842 | + free(b); | |
| 843 | + poperror(); | |
| 844 | + return n; | |
| 845 | + | |
| 846 | + case Qzero: | |
| 847 | + memset(buf, 0, n); | |
| 848 | + return n; | |
| 849 | + | |
| 850 | + case Qosversion: | |
| 851 | + snprint(tmp, sizeof tmp, "2000"); | |
| 852 | + n = readstr((ulong)offset, buf, n, tmp); | |
| 853 | + return n; | |
| 854 | + | |
| 855 | + default: | |
| 856 | + print("consread 0x%llux\n", c->qid.path); | |
| 857 | + error(Egreg); | |
| 858 | + } | |
| 859 | + return -1; /* never reached */ | |
| 860 | +} | |
| 861 | + | |
| 862 | +static long | |
| 863 | +conswrite(Chan *c, void *va, long n, vlong off) | |
| 864 | +{ | |
| 865 | + char buf[256]; | |
| 866 | + long l, bp; | |
| 867 | + char *a = va; | |
| 868 | + int id, fd; | |
| 869 | + Chan *swc; | |
| 870 | + ulong offset = off; | |
| 871 | + Cmdbuf *cb; | |
| 872 | + Cmdtab *ct; | |
| 873 | + | |
| 874 | + switch((ulong)c->qid.path){ | |
| 875 | + case Qcons: | |
| 876 | + /* | |
| 877 | + * Can't page fault in putstrn, so copy the data locally. | |
| 878 | + */ | |
| 879 | + l = n; | |
| 880 | + while(l > 0){ | |
| 881 | + bp = l; | |
| 882 | + if(bp > sizeof buf) | |
| 883 | + bp = sizeof buf; | |
| 884 | + memmove(buf, a, bp); | |
| 885 | + putstrn0(buf, bp, 1); | |
| 886 | + a += bp; | |
| 887 | + l -= bp; | |
| 888 | + } | |
| 889 | + break; | |
| 890 | + | |
| 891 | + case Qconsctl: | |
| 892 | + if(n >= sizeof(buf)) | |
| 893 | + n = sizeof(buf)-1; | |
| 894 | + strncpy(buf, a, n); | |
| 895 | + buf[n] = 0; | |
| 896 | + for(a = buf; a;){ | |
| 897 | + if(strncmp(a, "rawon", 5) == 0){ | |
| 898 | + qlock(&kbd.lk); | |
| 899 | + if(kbd.x){ | |
| 900 | + qwrite(kbdq, kbd.line, kbd.x); | |
| 901 | + kbd.x = 0; | |
| 902 | + } | |
| 903 | + kbd.raw = 1; | |
| 904 | + qunlock(&kbd.lk); | |
| 905 | + } else if(strncmp(a, "rawoff", 6) == 0){ | |
| 906 | + qlock(&kbd.lk); | |
| 907 | + kbd.raw = 0; | |
| 908 | + kbd.x = 0; | |
| 909 | + qunlock(&kbd.lk); | |
| 910 | + } else if(strncmp(a, "ctlpon", 6) == 0){ | |
| 911 | + kbd.ctlpoff = 0; | |
| 912 | + } else if(strncmp(a, "ctlpoff", 7) == 0){ | |
| 913 | + kbd.ctlpoff = 1; | |
| 914 | + } | |
| 915 | + if(a = strchr(a, ' ')) | |
| 916 | + a++; | |
| 917 | + } | |
| 918 | + break; | |
| 919 | + | |
| 920 | + case Qtime: | |
| 921 | + if(!iseve()) | |
| 922 | + error(Eperm); | |
| 923 | + return writetime(a, n); | |
| 924 | + | |
| 925 | + case Qbintime: | |
| 926 | + if(!iseve()) | |
| 927 | + error(Eperm); | |
| 928 | + return writebintime(a, n); | |
| 929 | + | |
| 930 | + case Qhostowner: | |
| 931 | + return hostownerwrite(a, n); | |
| 932 | + | |
| 933 | + case Qhostdomain: | |
| 934 | + return hostdomainwrite(a, n); | |
| 935 | + | |
| 936 | + case Quser: | |
| 937 | + return userwrite(a, n); | |
| 938 | + | |
| 939 | + case Qnull: | |
| 940 | + break; | |
| 941 | + | |
| 942 | + case Qreboot: | |
| 943 | + if(!iseve()) | |
| 944 | + error(Eperm); | |
| 945 | + cb = parsecmd(a, n); | |
| 946 | + | |
| 947 | + if(waserror()) { | |
| 948 | + free(cb); | |
| 949 | + nexterror(); | |
| 950 | + } | |
| 951 | + ct = lookupcmd(cb, rebootmsg, nelem(rebootmsg)); | |
| 952 | + switch(ct->index) { | |
| 953 | + case CMreboot: | |
| 954 | + rebootcmd(cb->nf-1, cb->f+1); | |
| 955 | + break; | |
| 956 | + case CMpanic: | |
| 957 | + panic("/dev/reboot"); | |
| 958 | + } | |
| 959 | + poperror(); | |
| 960 | + free(cb); | |
| 961 | + break; | |
| 962 | + | |
| 963 | + case Qsecstore: | |
| 964 | + if(offset >= sizeof secstorebuf || offset+n+1 >= sizeof secstorebuf) | |
| 965 | + error(Etoobig); | |
| 966 | + secstoretab->qid.vers++; | |
| 967 | + memmove(secstorebuf+offset, va, n); | |
| 968 | + return n; | |
| 969 | + | |
| 970 | + case Qsnarf: | |
| 971 | + if(offset >= SnarfSize || offset+n >= SnarfSize) | |
| 972 | + error(Etoobig); | |
| 973 | + snarftab->qid.vers++; | |
| 974 | + memmove((uchar*)c->aux+offset, va, n); | |
| 975 | + return n; | |
| 976 | + | |
| 977 | + case Qsysstat: | |
| 978 | + n = 0; | |
| 979 | + break; | |
| 980 | + | |
| 981 | + case Qswap: | |
| 982 | + if(n >= sizeof buf) | |
| 983 | + error(Egreg); | |
| 984 | + memmove(buf, va, n); /* so we can NUL-terminate */ | |
| 985 | + buf[n] = 0; | |
| 986 | + /* start a pager if not already started */ | |
| 987 | + if(strncmp(buf, "start", 5) == 0){ | |
| 988 | + kickpager(); | |
| 989 | + break; | |
| 990 | + } | |
| 991 | + if(cpuserver && !iseve()) | |
| 992 | + error(Eperm); | |
| 993 | + if(buf[0]<'0' || '9'<buf[0]) | |
| 994 | + error(Ebadarg); | |
| 995 | + fd = strtoul(buf, 0, 0); | |
| 996 | + swc = fdtochan(fd, -1, 1, 1); | |
| 997 | + setswapchan(swc); | |
| 998 | + break; | |
| 999 | + | |
| 1000 | + case Qsysname: | |
| 1001 | + if(offset != 0) | |
| 1002 | + error(Ebadarg); | |
| 1003 | + if(n <= 0 || n >= sizeof buf) | |
| 1004 | + error(Ebadarg); | |
| 1005 | + strncpy(buf, a, n); | |
| 1006 | + buf[n] = 0; | |
| 1007 | + if(buf[n-1] == '\n') | |
| 1008 | + buf[n-1] = 0; | |
| 1009 | + kstrdup(&sysname, buf); | |
| 1010 | + break; | |
| 1011 | + | |
| 1012 | + default: | |
| 1013 | + print("conswrite: 0x%llux\n", c->qid.path); | |
| 1014 | + error(Egreg); | |
| 1015 | + } | |
| 1016 | + return n; | |
| 1017 | +} | |
| 1018 | + | |
| 1019 | +Dev consdevtab = { | |
| 1020 | + 'c', | |
| 1021 | + "cons", | |
| 1022 | + | |
| 1023 | + devreset, | |
| 1024 | + consinit, | |
| 1025 | + devshutdown, | |
| 1026 | + consattach, | |
| 1027 | + conswalk, | |
| 1028 | + consstat, | |
| 1029 | + consopen, | |
| 1030 | + devcreate, | |
| 1031 | + consclose, | |
| 1032 | + consread, | |
| 1033 | + devbread, | |
| 1034 | + conswrite, | |
| 1035 | + devbwrite, | |
| 1036 | + devremove, | |
| 1037 | + devwstat, | |
| 1038 | +}; | |
| 1039 | + | |
| 1040 | +static ulong randn; | |
| 1041 | + | |
| 1042 | +static void | |
| 1043 | +seedrand(void) | |
| 1044 | +{ | |
| 1045 | + randomread((void*)&randn, sizeof(randn)); | |
| 1046 | +} | |
| 1047 | + | |
| 1048 | +// int | |
| 1049 | +// nrand(int n) | |
| 1050 | +// { | |
| 1051 | +// if(randn == 0) | |
| 1052 | +// seedrand(); | |
| 1053 | +// randn = randn*1103515245 + 12345 + fastticks(0); | |
| 1054 | +// return (randn>>16) % n; | |
| 1055 | +// } | |
| 1056 | + | |
| 1057 | +int | |
| 1058 | +rand(void) | |
| 1059 | +{ | |
| 1060 | + nrand(1); | |
| 1061 | + return randn; | |
| 1062 | +} | |
| 1063 | + | |
| 1064 | +/* static uvlong uvorder = 0x0001020304050607ULL; */ | |
| 1065 | +static uvlong uvorder = (uvlong)0x0001020304050607; | |
| 1066 | + | |
| 1067 | +static uchar* | |
| 1068 | +le2vlong(vlong *to, uchar *f) | |
| 1069 | +{ | |
| 1070 | + uchar *t, *o; | |
| 1071 | + int i; | |
| 1072 | + | |
| 1073 | + t = (uchar*)to; | |
| 1074 | + o = (uchar*)&uvorder; | |
| 1075 | + for(i = 0; i < sizeof(vlong); i++) | |
| 1076 | + t[o[i]] = f[i]; | |
| 1077 | + return f+sizeof(vlong); | |
| 1078 | +} | |
| 1079 | + | |
| 1080 | +static uchar* | |
| 1081 | +vlong2le(uchar *t, vlong from) | |
| 1082 | +{ | |
| 1083 | + uchar *f, *o; | |
| 1084 | + int i; | |
| 1085 | + | |
| 1086 | + f = (uchar*)&from; | |
| 1087 | + o = (uchar*)&uvorder; | |
| 1088 | + for(i = 0; i < sizeof(vlong); i++) | |
| 1089 | + t[i] = f[o[i]]; | |
| 1090 | + return t+sizeof(vlong); | |
| 1091 | +} | |
| 1092 | + | |
| 1093 | +static long order = 0x00010203; | |
| 1094 | + | |
| 1095 | +static uchar* | |
| 1096 | +le2long(long *to, uchar *f) | |
| 1097 | +{ | |
| 1098 | + uchar *t, *o; | |
| 1099 | + int i; | |
| 1100 | + | |
| 1101 | + t = (uchar*)to; | |
| 1102 | + o = (uchar*)ℴ | |
| 1103 | + for(i = 0; i < sizeof(long); i++) | |
| 1104 | + t[o[i]] = f[i]; | |
| 1105 | + return f+sizeof(long); | |
| 1106 | +} | |
| 1107 | + | |
| 1108 | +static uchar* | |
| 1109 | +long2le(uchar *t, long from) | |
| 1110 | +{ | |
| 1111 | + uchar *f, *o; | |
| 1112 | + int i; | |
| 1113 | + | |
| 1114 | + f = (uchar*)&from; | |
| 1115 | + o = (uchar*)ℴ | |
| 1116 | + for(i = 0; i < sizeof(long); i++) | |
| 1117 | + t[i] = f[o[i]]; | |
| 1118 | + return t+sizeof(long); | |
| 1119 | +} | |
| 1120 | + | |
| 1121 | +char *Ebadtimectl = "bad time control"; | |
| 1122 | + | |
| 1123 | +/* | |
| 1124 | + * like the old #c/time but with added info. Return | |
| 1125 | + * | |
| 1126 | + * secs nanosecs fastticks fasthz | |
| 1127 | + */ | |
| 1128 | +static int | |
| 1129 | +readtime(ulong off, char *buf, int n) | |
| 1130 | +{ | |
| 1131 | + vlong nsec, ticks; | |
| 1132 | + long sec; | |
| 1133 | + char str[7*NUMSIZE]; | |
| 1134 | + | |
| 1135 | + nsec = todget(&ticks); | |
| 1136 | + if(fasthz == (vlong)0) | |
| 1137 | + fastticks((uvlong*)&fasthz); | |
| 1138 | + sec = nsec/((uvlong) 1000000000); | |
| 1139 | + snprint(str, sizeof(str), "%*.0lud %*.0llud %*.0llud %*.0llud ", | |
| 1140 | + NUMSIZE-1, sec, | |
| 1141 | + VLNUMSIZE-1, nsec, | |
| 1142 | + VLNUMSIZE-1, ticks, | |
| 1143 | + VLNUMSIZE-1, fasthz); | |
| 1144 | + return readstr(off, buf, n, str); | |
| 1145 | +} | |
| 1146 | + | |
| 1147 | +/* | |
| 1148 | + * set the time in seconds | |
| 1149 | + */ | |
| 1150 | +static int | |
| 1151 | +writetime(char *buf, int n) | |
| 1152 | +{ | |
| 1153 | + char b[13]; | |
| 1154 | + long i; | |
| 1155 | + vlong now; | |
| 1156 | + | |
| 1157 | + if(n >= sizeof(b)) | |
| 1158 | + error(Ebadtimectl); | |
| 1159 | + strncpy(b, buf, n); | |
| 1160 | + b[n] = 0; | |
| 1161 | + i = strtol(b, 0, 0); | |
| 1162 | + if(i <= 0) | |
| 1163 | + error(Ebadtimectl); | |
| 1164 | + now = i*((vlong) 1000000000); | |
| 1165 | + todset(now, 0, 0); | |
| 1166 | + return n; | |
| 1167 | +} | |
| 1168 | + | |
| 1169 | +/* | |
| 1170 | + * read binary time info. all numbers are little endian. | |
| 1171 | + * ticks and nsec are syncronized. | |
| 1172 | + */ | |
| 1173 | +static int | |
| 1174 | +readbintime(char *buf, int n) | |
| 1175 | +{ | |
| 1176 | + int i; | |
| 1177 | + vlong nsec, ticks; | |
| 1178 | + uchar *b = (uchar*)buf; | |
| 1179 | + | |
| 1180 | + i = 0; | |
| 1181 | + if(fasthz == (vlong)0) | |
| 1182 | + fastticks((uvlong*)&fasthz); | |
| 1183 | + nsec = todget(&ticks); | |
| 1184 | + if(n >= 3*sizeof(uvlong)){ | |
| 1185 | + vlong2le(b+2*sizeof(uvlong), fasthz); | |
| 1186 | + i += sizeof(uvlong); | |
| 1187 | + } | |
| 1188 | + if(n >= 2*sizeof(uvlong)){ | |
| 1189 | + vlong2le(b+sizeof(uvlong), ticks); | |
| 1190 | + i += sizeof(uvlong); | |
| 1191 | + } | |
| 1192 | + if(n >= 8){ | |
| 1193 | + vlong2le(b, nsec); | |
| 1194 | + i += sizeof(vlong); | |
| 1195 | + } | |
| 1196 | + return i; | |
| 1197 | +} | |
| 1198 | + | |
| 1199 | +/* | |
| 1200 | + * set any of the following | |
| 1201 | + * - time in nsec | |
| 1202 | + * - nsec trim applied over some seconds | |
| 1203 | + * - clock frequency | |
| 1204 | + */ | |
| 1205 | +static int | |
| 1206 | +writebintime(char *buf, int n) | |
| 1207 | +{ | |
| 1208 | + uchar *p; | |
| 1209 | + vlong delta; | |
| 1210 | + long period; | |
| 1211 | + | |
| 1212 | + n--; | |
| 1213 | + p = (uchar*)buf + 1; | |
| 1214 | + switch(*buf){ | |
| 1215 | + case 'n': | |
| 1216 | + if(n < sizeof(vlong)) | |
| 1217 | + error(Ebadtimectl); | |
| 1218 | + le2vlong(&delta, p); | |
| 1219 | + todset(delta, 0, 0); | |
| 1220 | + break; | |
| 1221 | + case 'd': | |
| 1222 | + if(n < sizeof(vlong)+sizeof(long)) | |
| 1223 | + error(Ebadtimectl); | |
| 1224 | + p = le2vlong(&delta, p); | |
| 1225 | + le2long(&period, p); | |
| 1226 | + todset(-1, delta, period); | |
| 1227 | + break; | |
| 1228 | + case 'f': | |
| 1229 | + if(n < sizeof(uvlong)) | |
| 1230 | + error(Ebadtimectl); | |
| 1231 | + le2vlong(&fasthz, p); | |
| 1232 | + todsetfreq(fasthz); | |
| 1233 | + break; | |
| 1234 | + } | |
| 1235 | + return n; | |
| 1236 | +} | |
| 1237 | + | |
| 1238 | + | |
| @@ -0,0 +1,2100 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +#define Image IMAGE | |
| 8 | +#include <draw.h> | |
| 9 | +#include <memdraw.h> | |
| 10 | +#include <memlayer.h> | |
| 11 | +#include <cursor.h> | |
| 12 | +#include "screen.h" | |
| 13 | + | |
| 14 | +enum | |
| 15 | +{ | |
| 16 | + Qtopdir = 0, | |
| 17 | + Qnew, | |
| 18 | + Q3rd, | |
| 19 | + Q2nd, | |
| 20 | + Qcolormap, | |
| 21 | + Qctl, | |
| 22 | + Qdata, | |
| 23 | + Qrefresh, | |
| 24 | +}; | |
| 25 | + | |
| 26 | +/* | |
| 27 | + * Qid path is: | |
| 28 | + * 4 bits of file type (qids above) | |
| 29 | + * 24 bits of mux slot number +1; 0 means not attached to client | |
| 30 | + */ | |
| 31 | +#define QSHIFT 4 /* location in qid of client # */ | |
| 32 | + | |
| 33 | +#define QID(q) ((((ulong)(q).path)&0x0000000F)>>0) | |
| 34 | +#define CLIENTPATH(q) ((((ulong)q)&0x7FFFFFF0)>>QSHIFT) | |
| 35 | +#define CLIENT(q) CLIENTPATH((q).path) | |
| 36 | + | |
| 37 | +#define NHASH (1<<5) | |
| 38 | +#define HASHMASK (NHASH-1) | |
| 39 | +#define IOUNIT (64*1024) | |
| 40 | + | |
| 41 | +typedef struct Client Client; | |
| 42 | +typedef struct Draw Draw; | |
| 43 | +typedef struct DImage DImage; | |
| 44 | +typedef struct DScreen DScreen; | |
| 45 | +typedef struct CScreen CScreen; | |
| 46 | +typedef struct FChar FChar; | |
| 47 | +typedef struct Refresh Refresh; | |
| 48 | +typedef struct Refx Refx; | |
| 49 | +typedef struct DName DName; | |
| 50 | + | |
| 51 | +ulong blanktime = 30; /* in minutes; a half hour */ | |
| 52 | + | |
| 53 | +struct Draw | |
| 54 | +{ | |
| 55 | + QLock lk; | |
| 56 | + int clientid; | |
| 57 | + int nclient; | |
| 58 | + Client** client; | |
| 59 | + int nname; | |
| 60 | + DName* name; | |
| 61 | + int vers; | |
| 62 | + int softscreen; | |
| 63 | + int blanked; /* screen turned off */ | |
| 64 | + ulong blanktime; /* time of last operation */ | |
| 65 | + ulong savemap[3*256]; | |
| 66 | +}; | |
| 67 | + | |
| 68 | +struct Client | |
| 69 | +{ | |
| 70 | + Ref r; | |
| 71 | + DImage* dimage[NHASH]; | |
| 72 | + CScreen* cscreen; | |
| 73 | + Refresh* refresh; | |
| 74 | + Rendez refrend; | |
| 75 | + uchar* readdata; | |
| 76 | + int nreaddata; | |
| 77 | + int busy; | |
| 78 | + int clientid; | |
| 79 | + int slot; | |
| 80 | + int refreshme; | |
| 81 | + int infoid; | |
| 82 | + int op; | |
| 83 | +}; | |
| 84 | + | |
| 85 | +struct Refresh | |
| 86 | +{ | |
| 87 | + DImage* dimage; | |
| 88 | + Rectangle r; | |
| 89 | + Refresh* next; | |
| 90 | +}; | |
| 91 | + | |
| 92 | +struct Refx | |
| 93 | +{ | |
| 94 | + Client* client; | |
| 95 | + DImage* dimage; | |
| 96 | +}; | |
| 97 | + | |
| 98 | +struct DName | |
| 99 | +{ | |
| 100 | + char *name; | |
| 101 | + Client *client; | |
| 102 | + DImage* dimage; | |
| 103 | + int vers; | |
| 104 | +}; | |
| 105 | + | |
| 106 | +struct FChar | |
| 107 | +{ | |
| 108 | + int minx; /* left edge of bits */ | |
| 109 | + int maxx; /* right edge of bits */ | |
| 110 | + uchar miny; /* first non-zero scan-line */ | |
| 111 | + uchar maxy; /* last non-zero scan-line + 1 */ | |
| 112 | + schar left; /* offset of baseline */ | |
| 113 | + uchar width; /* width of baseline */ | |
| 114 | +}; | |
| 115 | + | |
| 116 | +/* | |
| 117 | + * Reference counts in DImages: | |
| 118 | + * one per open by original client | |
| 119 | + * one per screen image or fill | |
| 120 | + * one per image derived from this one by name | |
| 121 | + */ | |
| 122 | +struct DImage | |
| 123 | +{ | |
| 124 | + int id; | |
| 125 | + int ref; | |
| 126 | + char *name; | |
| 127 | + int vers; | |
| 128 | + Memimage* image; | |
| 129 | + int ascent; | |
| 130 | + int nfchar; | |
| 131 | + FChar* fchar; | |
| 132 | + DScreen* dscreen; /* 0 if not a window */ | |
| 133 | + DImage* fromname; /* image this one is derived from, by name */ | |
| 134 | + DImage* next; | |
| 135 | +}; | |
| 136 | + | |
| 137 | +struct CScreen | |
| 138 | +{ | |
| 139 | + DScreen* dscreen; | |
| 140 | + CScreen* next; | |
| 141 | +}; | |
| 142 | + | |
| 143 | +struct DScreen | |
| 144 | +{ | |
| 145 | + int id; | |
| 146 | + int public; | |
| 147 | + int ref; | |
| 148 | + DImage *dimage; | |
| 149 | + DImage *dfill; | |
| 150 | + Memscreen* screen; | |
| 151 | + Client* owner; | |
| 152 | + DScreen* next; | |
| 153 | +}; | |
| 154 | + | |
| 155 | +static Draw sdraw; | |
| 156 | +static Memimage *screenimage; | |
| 157 | +static Memdata screendata; | |
| 158 | +static Rectangle flushrect; | |
| 159 | +static int waste; | |
| 160 | +static DScreen* dscreen; | |
| 161 | +extern void flushmemscreen(Rectangle); | |
| 162 | + void drawmesg(Client*, void*, int); | |
| 163 | + void drawuninstall(Client*, int); | |
| 164 | + void drawfreedimage(DImage*); | |
| 165 | + Client* drawclientofpath(ulong); | |
| 166 | + | |
| 167 | +static char Enodrawimage[] = "unknown id for draw image"; | |
| 168 | +static char Enodrawscreen[] = "unknown id for draw screen"; | |
| 169 | +static char Eshortdraw[] = "short draw message"; | |
| 170 | +static char Eshortread[] = "draw read too short"; | |
| 171 | +static char Eimageexists[] = "image id in use"; | |
| 172 | +static char Escreenexists[] = "screen id in use"; | |
| 173 | +static char Edrawmem[] = "image memory allocation failed"; | |
| 174 | +static char Ereadoutside[] = "readimage outside image"; | |
| 175 | +static char Ewriteoutside[] = "writeimage outside image"; | |
| 176 | +static char Enotfont[] = "image not a font"; | |
| 177 | +static char Eindex[] = "character index out of range"; | |
| 178 | +static char Enoclient[] = "no such draw client"; | |
| 179 | +static char Edepth[] = "image has bad depth"; | |
| 180 | +static char Enameused[] = "image name in use"; | |
| 181 | +static char Enoname[] = "no image with that name"; | |
| 182 | +static char Eoldname[] = "named image no longer valid"; | |
| 183 | +static char Enamed[] = "image already has name"; | |
| 184 | +static char Ewrongname[] = "wrong name for image"; | |
| 185 | + | |
| 186 | +static int | |
| 187 | +drawgen(Chan *c, char *name, Dirtab *dt, int ndt, int s, Dir *dp) | |
| 188 | +{ | |
| 189 | + int t; | |
| 190 | + Qid q; | |
| 191 | + ulong path; | |
| 192 | + Client *cl; | |
| 193 | + | |
| 194 | + USED(name); | |
| 195 | + USED(dt); | |
| 196 | + USED(ndt); | |
| 197 | + | |
| 198 | + q.vers = 0; | |
| 199 | + | |
| 200 | + if(s == DEVDOTDOT){ | |
| 201 | + switch(QID(c->qid)){ | |
| 202 | + case Qtopdir: | |
| 203 | + case Q2nd: | |
| 204 | + mkqid(&q, Qtopdir, 0, QTDIR); | |
| 205 | + devdir(c, q, "#i", 0, eve, 0500, dp); | |
| 206 | + break; | |
| 207 | + case Q3rd: | |
| 208 | + cl = drawclientofpath(c->qid.path); | |
| 209 | + if(cl == nil) | |
| 210 | + strcpy(up->genbuf, "??"); | |
| 211 | + else | |
| 212 | + sprint(up->genbuf, "%d", cl->clientid); | |
| 213 | + mkqid(&q, Q2nd, 0, QTDIR); | |
| 214 | + devdir(c, q, up->genbuf, 0, eve, 0500, dp); | |
| 215 | + break; | |
| 216 | + default: | |
| 217 | + panic("drawwalk %llux", c->qid.path); | |
| 218 | + } | |
| 219 | + return 1; | |
| 220 | + } | |
| 221 | + | |
| 222 | + /* | |
| 223 | + * Top level directory contains the name of the device. | |
| 224 | + */ | |
| 225 | + t = QID(c->qid); | |
| 226 | + if(t == Qtopdir){ | |
| 227 | + switch(s){ | |
| 228 | + case 0: | |
| 229 | + mkqid(&q, Q2nd, 0, QTDIR); | |
| 230 | + devdir(c, q, "draw", 0, eve, 0555, dp); | |
| 231 | + break; | |
| 232 | + default: | |
| 233 | + return -1; | |
| 234 | + } | |
| 235 | + return 1; | |
| 236 | + } | |
| 237 | + | |
| 238 | + /* | |
| 239 | + * Second level contains "new" plus all the clients. | |
| 240 | + */ | |
| 241 | + if(t == Q2nd || t == Qnew){ | |
| 242 | + if(s == 0){ | |
| 243 | + mkqid(&q, Qnew, 0, QTFILE); | |
| 244 | + devdir(c, q, "new", 0, eve, 0666, dp); | |
| 245 | + } | |
| 246 | + else if(s <= sdraw.nclient){ | |
| 247 | + cl = sdraw.client[s-1]; | |
| 248 | + if(cl == 0) | |
| 249 | + return 0; | |
| 250 | + sprint(up->genbuf, "%d", cl->clientid); | |
| 251 | + mkqid(&q, (s<<QSHIFT)|Q3rd, 0, QTDIR); | |
| 252 | + devdir(c, q, up->genbuf, 0, eve, 0555, dp); | |
| 253 | + return 1; | |
| 254 | + } | |
| 255 | + else | |
| 256 | + return -1; | |
| 257 | + return 1; | |
| 258 | + } | |
| 259 | + | |
| 260 | + /* | |
| 261 | + * Third level. | |
| 262 | + */ | |
| 263 | + path = c->qid.path&~((1<<QSHIFT)-1); /* slot component */ | |
| 264 | + q.vers = c->qid.vers; | |
| 265 | + q.type = QTFILE; | |
| 266 | + switch(s){ | |
| 267 | + case 0: | |
| 268 | + q.path = path|Qcolormap; | |
| 269 | + devdir(c, q, "colormap", 0, eve, 0600, dp); | |
| 270 | + break; | |
| 271 | + case 1: | |
| 272 | + q.path = path|Qctl; | |
| 273 | + devdir(c, q, "ctl", 0, eve, 0600, dp); | |
| 274 | + break; | |
| 275 | + case 2: | |
| 276 | + q.path = path|Qdata; | |
| 277 | + devdir(c, q, "data", 0, eve, 0600, dp); | |
| 278 | + break; | |
| 279 | + case 3: | |
| 280 | + q.path = path|Qrefresh; | |
| 281 | + devdir(c, q, "refresh", 0, eve, 0400, dp); | |
| 282 | + break; | |
| 283 | + default: | |
| 284 | + return -1; | |
| 285 | + } | |
| 286 | + return 1; | |
| 287 | +} | |
| 288 | + | |
| 289 | +static | |
| 290 | +int | |
| 291 | +drawrefactive(void *a) | |
| 292 | +{ | |
| 293 | + Client *c; | |
| 294 | + | |
| 295 | + c = a; | |
| 296 | + return c->refreshme || c->refresh!=0; | |
| 297 | +} | |
| 298 | + | |
| 299 | +static | |
| 300 | +void | |
| 301 | +drawrefreshscreen(DImage *l, Client *client) | |
| 302 | +{ | |
| 303 | + while(l != nil && l->dscreen == nil) | |
| 304 | + l = l->fromname; | |
| 305 | + if(l != nil && l->dscreen->owner != client) | |
| 306 | + l->dscreen->owner->refreshme = 1; | |
| 307 | +} | |
| 308 | + | |
| 309 | +static | |
| 310 | +void | |
| 311 | +drawrefresh(Memimage *m, Rectangle r, void *v) | |
| 312 | +{ | |
| 313 | + Refx *x; | |
| 314 | + DImage *d; | |
| 315 | + Client *c; | |
| 316 | + Refresh *ref; | |
| 317 | + | |
| 318 | + USED(m); | |
| 319 | + | |
| 320 | + if(v == 0) | |
| 321 | + return; | |
| 322 | + x = v; | |
| 323 | + c = x->client; | |
| 324 | + d = x->dimage; | |
| 325 | + for(ref=c->refresh; ref; ref=ref->next) | |
| 326 | + if(ref->dimage == d){ | |
| 327 | + combinerect(&ref->r, r); | |
| 328 | + return; | |
| 329 | + } | |
| 330 | + ref = malloc(sizeof(Refresh)); | |
| 331 | + if(ref){ | |
| 332 | + ref->dimage = d; | |
| 333 | + ref->r = r; | |
| 334 | + ref->next = c->refresh; | |
| 335 | + c->refresh = ref; | |
| 336 | + } | |
| 337 | +} | |
| 338 | + | |
| 339 | +static void | |
| 340 | +addflush(Rectangle r) | |
| 341 | +{ | |
| 342 | + int abb, ar, anbb; | |
| 343 | + Rectangle nbb; | |
| 344 | + | |
| 345 | + if(sdraw.softscreen==0 || !rectclip(&r, screenimage->r)) | |
| 346 | + return; | |
| 347 | + | |
| 348 | + if(flushrect.min.x >= flushrect.max.x){ | |
| 349 | + flushrect = r; | |
| 350 | + waste = 0; | |
| 351 | + return; | |
| 352 | + } | |
| 353 | + nbb = flushrect; | |
| 354 | + combinerect(&nbb, r); | |
| 355 | + ar = Dx(r)*Dy(r); | |
| 356 | + abb = Dx(flushrect)*Dy(flushrect); | |
| 357 | + anbb = Dx(nbb)*Dy(nbb); | |
| 358 | + /* | |
| 359 | + * Area of new waste is area of new bb minus area of old bb, | |
| 360 | + * less the area of the new segment, which we assume is not waste. | |
| 361 | + * This could be negative, but that's OK. | |
| 362 | + */ | |
| 363 | + waste += anbb-abb - ar; | |
| 364 | + if(waste < 0) | |
| 365 | + waste = 0; | |
| 366 | + /* | |
| 367 | + * absorb if: | |
| 368 | + * total area is small | |
| 369 | + * waste is less than half total area | |
| 370 | + * rectangles touch | |
| 371 | + */ | |
| 372 | + if(anbb<=1024 || waste*2<anbb || rectXrect(flushrect, r)){ | |
| 373 | + flushrect = nbb; | |
| 374 | + return; | |
| 375 | + } | |
| 376 | + /* emit current state */ | |
| 377 | + if(flushrect.min.x < flushrect.max.x) | |
| 378 | + flushmemscreen(flushrect); | |
| 379 | + flushrect = r; | |
| 380 | + waste = 0; | |
| 381 | +} | |
| 382 | + | |
| 383 | +static | |
| 384 | +void | |
| 385 | +dstflush(int dstid, Memimage *dst, Rectangle r) | |
| 386 | +{ | |
| 387 | + Memlayer *l; | |
| 388 | + | |
| 389 | + if(dstid == 0){ | |
| 390 | + combinerect(&flushrect, r); | |
| 391 | + return; | |
| 392 | + } | |
| 393 | + /* how can this happen? -rsc, dec 12 2002 */ | |
| 394 | + if(dst == 0){ | |
| 395 | + print("nil dstflush\n"); | |
| 396 | + return; | |
| 397 | + } | |
| 398 | + l = dst->layer; | |
| 399 | + if(l == nil) | |
| 400 | + return; | |
| 401 | + do{ | |
| 402 | + if(l->screen->image->data != screenimage->data) | |
| 403 | + return; | |
| 404 | + r = rectaddpt(r, l->delta); | |
| 405 | + l = l->screen->image->layer; | |
| 406 | + }while(l); | |
| 407 | + addflush(r); | |
| 408 | +} | |
| 409 | + | |
| 410 | +void | |
| 411 | +drawflush(void) | |
| 412 | +{ | |
| 413 | + if(flushrect.min.x < flushrect.max.x) | |
| 414 | + flushmemscreen(flushrect); | |
| 415 | + flushrect = Rect(10000, 10000, -10000, -10000); | |
| 416 | +} | |
| 417 | + | |
| 418 | +void | |
| 419 | +drawflushr(Rectangle r) | |
| 420 | +{ | |
| 421 | + qlock(&sdraw.lk); | |
| 422 | + flushmemscreen(r); | |
| 423 | + qunlock(&sdraw.lk); | |
| 424 | +} | |
| 425 | + | |
| 426 | +static | |
| 427 | +int | |
| 428 | +drawcmp(char *a, char *b, int n) | |
| 429 | +{ | |
| 430 | + if(strlen(a) != n) | |
| 431 | + return 1; | |
| 432 | + return memcmp(a, b, n); | |
| 433 | +} | |
| 434 | + | |
| 435 | +DName* | |
| 436 | +drawlookupname(int n, char *str) | |
| 437 | +{ | |
| 438 | + DName *name, *ename; | |
| 439 | + | |
| 440 | + name = sdraw.name; | |
| 441 | + ename = &name[sdraw.nname]; | |
| 442 | + for(; name<ename; name++) | |
| 443 | + if(drawcmp(name->name, str, n) == 0) | |
| 444 | + return name; | |
| 445 | + return 0; | |
| 446 | +} | |
| 447 | + | |
| 448 | +int | |
| 449 | +drawgoodname(DImage *d) | |
| 450 | +{ | |
| 451 | + DName *n; | |
| 452 | + | |
| 453 | + /* if window, validate the screen's own images */ | |
| 454 | + if(d->dscreen) | |
| 455 | + if(drawgoodname(d->dscreen->dimage) == 0 | |
| 456 | + || drawgoodname(d->dscreen->dfill) == 0) | |
| 457 | + return 0; | |
| 458 | + if(d->name == nil) | |
| 459 | + return 1; | |
| 460 | + n = drawlookupname(strlen(d->name), d->name); | |
| 461 | + if(n==nil || n->vers!=d->vers) | |
| 462 | + return 0; | |
| 463 | + return 1; | |
| 464 | +} | |
| 465 | + | |
| 466 | +DImage* | |
| 467 | +drawlookup(Client *client, int id, int checkname) | |
| 468 | +{ | |
| 469 | + DImage *d; | |
| 470 | + | |
| 471 | + d = client->dimage[id&HASHMASK]; | |
| 472 | + while(d){ | |
| 473 | + if(d->id == id){ | |
| 474 | + if(checkname && !drawgoodname(d)) | |
| 475 | + error(Eoldname); | |
| 476 | + return d; | |
| 477 | + } | |
| 478 | + d = d->next; | |
| 479 | + } | |
| 480 | + return 0; | |
| 481 | +} | |
| 482 | + | |
| 483 | +DScreen* | |
| 484 | +drawlookupdscreen(int id) | |
| 485 | +{ | |
| 486 | + DScreen *s; | |
| 487 | + | |
| 488 | + s = dscreen; | |
| 489 | + while(s){ | |
| 490 | + if(s->id == id) | |
| 491 | + return s; | |
| 492 | + s = s->next; | |
| 493 | + } | |
| 494 | + return 0; | |
| 495 | +} | |
| 496 | + | |
| 497 | +DScreen* | |
| 498 | +drawlookupscreen(Client *client, int id, CScreen **cs) | |
| 499 | +{ | |
| 500 | + CScreen *s; | |
| 501 | + | |
| 502 | + s = client->cscreen; | |
| 503 | + while(s){ | |
| 504 | + if(s->dscreen->id == id){ | |
| 505 | + *cs = s; | |
| 506 | + return s->dscreen; | |
| 507 | + } | |
| 508 | + s = s->next; | |
| 509 | + } | |
| 510 | + error(Enodrawscreen); | |
| 511 | + return 0; | |
| 512 | +} | |
| 513 | + | |
| 514 | +Memimage* | |
| 515 | +drawinstall(Client *client, int id, Memimage *i, DScreen *dscreen) | |
| 516 | +{ | |
| 517 | + DImage *d; | |
| 518 | + | |
| 519 | + d = malloc(sizeof(DImage)); | |
| 520 | + if(d == 0) | |
| 521 | + return 0; | |
| 522 | + d->id = id; | |
| 523 | + d->ref = 1; | |
| 524 | + d->name = 0; | |
| 525 | + d->vers = 0; | |
| 526 | + d->image = i; | |
| 527 | + d->nfchar = 0; | |
| 528 | + d->fchar = 0; | |
| 529 | + d->fromname = 0; | |
| 530 | + d->dscreen = dscreen; | |
| 531 | + d->next = client->dimage[id&HASHMASK]; | |
| 532 | + client->dimage[id&HASHMASK] = d; | |
| 533 | + return i; | |
| 534 | +} | |
| 535 | + | |
| 536 | +Memscreen* | |
| 537 | +drawinstallscreen(Client *client, DScreen *d, int id, DImage *dimage, DImage *dfill, int public) | |
| 538 | +{ | |
| 539 | + Memscreen *s; | |
| 540 | + CScreen *c; | |
| 541 | + | |
| 542 | + c = malloc(sizeof(CScreen)); | |
| 543 | + if(dimage && dimage->image && dimage->image->chan == 0) | |
| 544 | + panic("bad image %p in drawinstallscreen", dimage->image); | |
| 545 | + | |
| 546 | + if(c == 0) | |
| 547 | + return 0; | |
| 548 | + if(d == 0){ | |
| 549 | + d = malloc(sizeof(DScreen)); | |
| 550 | + if(d == 0){ | |
| 551 | + free(c); | |
| 552 | + return 0; | |
| 553 | + } | |
| 554 | + s = malloc(sizeof(Memscreen)); | |
| 555 | + if(s == 0){ | |
| 556 | + free(c); | |
| 557 | + free(d); | |
| 558 | + return 0; | |
| 559 | + } | |
| 560 | + s->frontmost = 0; | |
| 561 | + s->rearmost = 0; | |
| 562 | + d->dimage = dimage; | |
| 563 | + if(dimage){ | |
| 564 | + s->image = dimage->image; | |
| 565 | + dimage->ref++; | |
| 566 | + } | |
| 567 | + d->dfill = dfill; | |
| 568 | + if(dfill){ | |
| 569 | + s->fill = dfill->image; | |
| 570 | + dfill->ref++; | |
| 571 | + } | |
| 572 | + d->ref = 0; | |
| 573 | + d->id = id; | |
| 574 | + d->screen = s; | |
| 575 | + d->public = public; | |
| 576 | + d->next = dscreen; | |
| 577 | + d->owner = client; | |
| 578 | + dscreen = d; | |
| 579 | + } | |
| 580 | + c->dscreen = d; | |
| 581 | + d->ref++; | |
| 582 | + c->next = client->cscreen; | |
| 583 | + client->cscreen = c; | |
| 584 | + return d->screen; | |
| 585 | +} | |
| 586 | + | |
| 587 | +void | |
| 588 | +drawdelname(DName *name) | |
| 589 | +{ | |
| 590 | + int i; | |
| 591 | + | |
| 592 | + i = name-sdraw.name; | |
| 593 | + memmove(name, name+1, (sdraw.nname-(i+1))*sizeof(DName)); | |
| 594 | + sdraw.nname--; | |
| 595 | +} | |
| 596 | + | |
| 597 | +void | |
| 598 | +drawfreedscreen(DScreen *this) | |
| 599 | +{ | |
| 600 | + DScreen *ds, *next; | |
| 601 | + | |
| 602 | + this->ref--; | |
| 603 | + if(this->ref < 0) | |
| 604 | + print("negative ref in drawfreedscreen\n"); | |
| 605 | + if(this->ref > 0) | |
| 606 | + return; | |
| 607 | + ds = dscreen; | |
| 608 | + if(ds == this){ | |
| 609 | + dscreen = this->next; | |
| 610 | + goto Found; | |
| 611 | + } | |
| 612 | + while(next = ds->next){ /* assign = */ | |
| 613 | + if(next == this){ | |
| 614 | + ds->next = this->next; | |
| 615 | + goto Found; | |
| 616 | + } | |
| 617 | + ds = next; | |
| 618 | + } | |
| 619 | + error(Enodrawimage); | |
| 620 | + | |
| 621 | + Found: | |
| 622 | + if(this->dimage) | |
| 623 | + drawfreedimage(this->dimage); | |
| 624 | + if(this->dfill) | |
| 625 | + drawfreedimage(this->dfill); | |
| 626 | + free(this->screen); | |
| 627 | + free(this); | |
| 628 | +} | |
| 629 | + | |
| 630 | +void | |
| 631 | +drawfreedimage(DImage *dimage) | |
| 632 | +{ | |
| 633 | + int i; | |
| 634 | + Memimage *l; | |
| 635 | + DScreen *ds; | |
| 636 | + | |
| 637 | + dimage->ref--; | |
| 638 | + if(dimage->ref < 0) | |
| 639 | + print("negative ref in drawfreedimage\n"); | |
| 640 | + if(dimage->ref > 0) | |
| 641 | + return; | |
| 642 | + | |
| 643 | + /* any names? */ | |
| 644 | + for(i=0; i<sdraw.nname; ) | |
| 645 | + if(sdraw.name[i].dimage == dimage) | |
| 646 | + drawdelname(sdraw.name+i); | |
| 647 | + else | |
| 648 | + i++; | |
| 649 | + if(dimage->fromname){ /* acquired by name; owned by someone else*/ | |
| 650 | + drawfreedimage(dimage->fromname); | |
| 651 | + goto Return; | |
| 652 | + } | |
| 653 | + if(dimage->image == screenimage) /* don't free the display */ | |
| 654 | + goto Return; | |
| 655 | + ds = dimage->dscreen; | |
| 656 | + if(ds){ | |
| 657 | + l = dimage->image; | |
| 658 | + if(l->data == screenimage->data) | |
| 659 | + addflush(l->layer->screenr); | |
| 660 | + if(l->layer->refreshfn == drawrefresh) /* else true owner will clean up */ | |
| 661 | + free(l->layer->refreshptr); | |
| 662 | + l->layer->refreshptr = nil; | |
| 663 | + if(drawgoodname(dimage)) | |
| 664 | + memldelete(l); | |
| 665 | + else | |
| 666 | + memlfree(l); | |
| 667 | + drawfreedscreen(ds); | |
| 668 | + }else | |
| 669 | + freememimage(dimage->image); | |
| 670 | + Return: | |
| 671 | + free(dimage->fchar); | |
| 672 | + free(dimage); | |
| 673 | +} | |
| 674 | + | |
| 675 | +void | |
| 676 | +drawuninstallscreen(Client *client, CScreen *this) | |
| 677 | +{ | |
| 678 | + CScreen *cs, *next; | |
| 679 | + | |
| 680 | + cs = client->cscreen; | |
| 681 | + if(cs == this){ | |
| 682 | + client->cscreen = this->next; | |
| 683 | + drawfreedscreen(this->dscreen); | |
| 684 | + free(this); | |
| 685 | + return; | |
| 686 | + } | |
| 687 | + while(next = cs->next){ /* assign = */ | |
| 688 | + if(next == this){ | |
| 689 | + cs->next = this->next; | |
| 690 | + drawfreedscreen(this->dscreen); | |
| 691 | + free(this); | |
| 692 | + return; | |
| 693 | + } | |
| 694 | + cs = next; | |
| 695 | + } | |
| 696 | +} | |
| 697 | + | |
| 698 | +void | |
| 699 | +drawuninstall(Client *client, int id) | |
| 700 | +{ | |
| 701 | + DImage *d, *next; | |
| 702 | + | |
| 703 | + d = client->dimage[id&HASHMASK]; | |
| 704 | + if(d == 0) | |
| 705 | + error(Enodrawimage); | |
| 706 | + if(d->id == id){ | |
| 707 | + client->dimage[id&HASHMASK] = d->next; | |
| 708 | + drawfreedimage(d); | |
| 709 | + return; | |
| 710 | + } | |
| 711 | + while(next = d->next){ /* assign = */ | |
| 712 | + if(next->id == id){ | |
| 713 | + d->next = next->next; | |
| 714 | + drawfreedimage(next); | |
| 715 | + return; | |
| 716 | + } | |
| 717 | + d = next; | |
| 718 | + } | |
| 719 | + error(Enodrawimage); | |
| 720 | +} | |
| 721 | + | |
| 722 | +void | |
| 723 | +drawaddname(Client *client, DImage *di, int n, char *str) | |
| 724 | +{ | |
| 725 | + DName *name, *ename, *new, *t; | |
| 726 | + | |
| 727 | + name = sdraw.name; | |
| 728 | + ename = &name[sdraw.nname]; | |
| 729 | + for(; name<ename; name++) | |
| 730 | + if(drawcmp(name->name, str, n) == 0) | |
| 731 | + error(Enameused); | |
| 732 | + t = smalloc((sdraw.nname+1)*sizeof(DName)); | |
| 733 | + memmove(t, sdraw.name, sdraw.nname*sizeof(DName)); | |
| 734 | + free(sdraw.name); | |
| 735 | + sdraw.name = t; | |
| 736 | + new = &sdraw.name[sdraw.nname++]; | |
| 737 | + new->name = smalloc(n+1); | |
| 738 | + memmove(new->name, str, n); | |
| 739 | + new->name[n] = 0; | |
| 740 | + new->dimage = di; | |
| 741 | + new->client = client; | |
| 742 | + new->vers = ++sdraw.vers; | |
| 743 | +} | |
| 744 | + | |
| 745 | +Client* | |
| 746 | +drawnewclient(void) | |
| 747 | +{ | |
| 748 | + Client *cl, **cp; | |
| 749 | + int i; | |
| 750 | + | |
| 751 | + for(i=0; i<sdraw.nclient; i++){ | |
| 752 | + cl = sdraw.client[i]; | |
| 753 | + if(cl == 0) | |
| 754 | + break; | |
| 755 | + } | |
| 756 | + if(i == sdraw.nclient){ | |
| 757 | + cp = malloc((sdraw.nclient+1)*sizeof(Client*)); | |
| 758 | + if(cp == 0) | |
| 759 | + return 0; | |
| 760 | + memmove(cp, sdraw.client, sdraw.nclient*sizeof(Client*)); | |
| 761 | + free(sdraw.client); | |
| 762 | + sdraw.client = cp; | |
| 763 | + sdraw.nclient++; | |
| 764 | + cp[i] = 0; | |
| 765 | + } | |
| 766 | + cl = malloc(sizeof(Client)); | |
| 767 | + if(cl == 0) | |
| 768 | + return 0; | |
| 769 | + memset(cl, 0, sizeof(Client)); | |
| 770 | + cl->slot = i; | |
| 771 | + cl->clientid = ++sdraw.clientid; | |
| 772 | + cl->op = SoverD; | |
| 773 | + sdraw.client[i] = cl; | |
| 774 | + return cl; | |
| 775 | +} | |
| 776 | + | |
| 777 | +static int | |
| 778 | +drawclientop(Client *cl) | |
| 779 | +{ | |
| 780 | + int op; | |
| 781 | + | |
| 782 | + op = cl->op; | |
| 783 | + cl->op = SoverD; | |
| 784 | + return op; | |
| 785 | +} | |
| 786 | + | |
| 787 | +int | |
| 788 | +drawhasclients(void) | |
| 789 | +{ | |
| 790 | + /* | |
| 791 | + * if draw has ever been used, we can't resize the frame buffer, | |
| 792 | + * even if all clients have exited (nclients is cumulative); it's too | |
| 793 | + * hard to make work. | |
| 794 | + */ | |
| 795 | + return sdraw.nclient != 0; | |
| 796 | +} | |
| 797 | + | |
| 798 | +Client* | |
| 799 | +drawclientofpath(ulong path) | |
| 800 | +{ | |
| 801 | + Client *cl; | |
| 802 | + int slot; | |
| 803 | + | |
| 804 | + slot = CLIENTPATH(path); | |
| 805 | + if(slot == 0) | |
| 806 | + return nil; | |
| 807 | + cl = sdraw.client[slot-1]; | |
| 808 | + if(cl==0 || cl->clientid==0) | |
| 809 | + return nil; | |
| 810 | + return cl; | |
| 811 | +} | |
| 812 | + | |
| 813 | + | |
| 814 | +Client* | |
| 815 | +drawclient(Chan *c) | |
| 816 | +{ | |
| 817 | + Client *client; | |
| 818 | + | |
| 819 | + client = drawclientofpath(c->qid.path); | |
| 820 | + if(client == nil) | |
| 821 | + error(Enoclient); | |
| 822 | + return client; | |
| 823 | +} | |
| 824 | + | |
| 825 | +Memimage* | |
| 826 | +drawimage(Client *client, uchar *a) | |
| 827 | +{ | |
| 828 | + DImage *d; | |
| 829 | + | |
| 830 | + d = drawlookup(client, BGLONG(a), 1); | |
| 831 | + if(d == nil) | |
| 832 | + error(Enodrawimage); | |
| 833 | + return d->image; | |
| 834 | +} | |
| 835 | + | |
| 836 | +void | |
| 837 | +drawrectangle(Rectangle *r, uchar *a) | |
| 838 | +{ | |
| 839 | + r->min.x = BGLONG(a+0*4); | |
| 840 | + r->min.y = BGLONG(a+1*4); | |
| 841 | + r->max.x = BGLONG(a+2*4); | |
| 842 | + r->max.y = BGLONG(a+3*4); | |
| 843 | +} | |
| 844 | + | |
| 845 | +void | |
| 846 | +drawpoint(Point *p, uchar *a) | |
| 847 | +{ | |
| 848 | + p->x = BGLONG(a+0*4); | |
| 849 | + p->y = BGLONG(a+1*4); | |
| 850 | +} | |
| 851 | + | |
| 852 | +Point | |
| 853 | +drawchar(Memimage *dst, Point p, Memimage *src, Point *sp, DImage *font, int index, int op) | |
| 854 | +{ | |
| 855 | + FChar *fc; | |
| 856 | + Rectangle r; | |
| 857 | + Point sp1; | |
| 858 | + | |
| 859 | + fc = &font->fchar[index]; | |
| 860 | + r.min.x = p.x+fc->left; | |
| 861 | + r.min.y = p.y-(font->ascent-fc->miny); | |
| 862 | + r.max.x = r.min.x+(fc->maxx-fc->minx); | |
| 863 | + r.max.y = r.min.y+(fc->maxy-fc->miny); | |
| 864 | + sp1.x = sp->x+fc->left; | |
| 865 | + sp1.y = sp->y+fc->miny; | |
| 866 | + memdraw(dst, r, src, sp1, font->image, Pt(fc->minx, fc->miny), op); | |
| 867 | + p.x += fc->width; | |
| 868 | + sp->x += fc->width; | |
| 869 | + return p; | |
| 870 | +} | |
| 871 | + | |
| 872 | +static int | |
| 873 | +initscreenimage(void) | |
| 874 | +{ | |
| 875 | + int width, depth; | |
| 876 | + ulong chan; | |
| 877 | + void *X; | |
| 878 | + Rectangle r; | |
| 879 | + | |
| 880 | + if(screenimage != nil) | |
| 881 | + return 1; | |
| 882 | + | |
| 883 | + screendata.base = nil; | |
| 884 | + screendata.bdata = attachscreen(&r, &chan, &depth, &width, &sdraw.softscreen, &X); | |
| 885 | + if(screendata.bdata == nil && X == nil) | |
| 886 | + return 0; | |
| 887 | + screendata.ref = 1; | |
| 888 | + | |
| 889 | + screenimage = allocmemimaged(r, chan, &screendata, X); | |
| 890 | + if(screenimage == nil){ | |
| 891 | + /* RSC: BUG: detach screen */ | |
| 892 | + return 0; | |
| 893 | + } | |
| 894 | + | |
| 895 | + screenimage->width = width; | |
| 896 | + screenimage->clipr = r; | |
| 897 | + return 1; | |
| 898 | +} | |
| 899 | + | |
| 900 | +void | |
| 901 | +deletescreenimage(void) | |
| 902 | +{ | |
| 903 | + qlock(&sdraw.lk); | |
| 904 | + /* RSC: BUG: detach screen */ | |
| 905 | + if(screenimage) | |
| 906 | + freememimage(screenimage); | |
| 907 | + screenimage = nil; | |
| 908 | + qunlock(&sdraw.lk); | |
| 909 | +} | |
| 910 | + | |
| 911 | +static Chan* | |
| 912 | +drawattach(char *spec) | |
| 913 | +{ | |
| 914 | + qlock(&sdraw.lk); | |
| 915 | + if(!initscreenimage()){ | |
| 916 | + qunlock(&sdraw.lk); | |
| 917 | + error("no frame buffer"); | |
| 918 | + } | |
| 919 | + qunlock(&sdraw.lk); | |
| 920 | + return devattach('i', spec); | |
| 921 | +} | |
| 922 | + | |
| 923 | +static Walkqid* | |
| 924 | +drawwalk(Chan *c, Chan *nc, char **name, int nname) | |
| 925 | +{ | |
| 926 | + if(screendata.bdata == nil) | |
| 927 | + error("no frame buffer"); | |
| 928 | + return devwalk(c, nc, name, nname, 0, 0, drawgen); | |
| 929 | +} | |
| 930 | + | |
| 931 | +static int | |
| 932 | +drawstat(Chan *c, uchar *db, int n) | |
| 933 | +{ | |
| 934 | + return devstat(c, db, n, 0, 0, drawgen); | |
| 935 | +} | |
| 936 | + | |
| 937 | +static Chan* | |
| 938 | +drawopen(Chan *c, int omode) | |
| 939 | +{ | |
| 940 | + Client *cl; | |
| 941 | + | |
| 942 | + if(c->qid.type & QTDIR){ | |
| 943 | + c = devopen(c, omode, 0, 0, drawgen); | |
| 944 | + c->iounit = IOUNIT; | |
| 945 | + } | |
| 946 | + | |
| 947 | + qlock(&sdraw.lk); | |
| 948 | + if(waserror()){ | |
| 949 | + qunlock(&sdraw.lk); | |
| 950 | + nexterror(); | |
| 951 | + } | |
| 952 | + | |
| 953 | + if(QID(c->qid) == Qnew){ | |
| 954 | + cl = drawnewclient(); | |
| 955 | + if(cl == 0) | |
| 956 | + error(Enodev); | |
| 957 | + c->qid.path = Qctl|((cl->slot+1)<<QSHIFT); | |
| 958 | + } | |
| 959 | + | |
| 960 | + switch(QID(c->qid)){ | |
| 961 | + case Qnew: | |
| 962 | + break; | |
| 963 | + | |
| 964 | + case Qctl: | |
| 965 | + cl = drawclient(c); | |
| 966 | + if(cl->busy) | |
| 967 | + error(Einuse); | |
| 968 | + cl->busy = 1; | |
| 969 | + flushrect = Rect(10000, 10000, -10000, -10000); | |
| 970 | + drawinstall(cl, 0, screenimage, 0); | |
| 971 | + incref(&cl->r); | |
| 972 | + break; | |
| 973 | + case Qcolormap: | |
| 974 | + case Qdata: | |
| 975 | + case Qrefresh: | |
| 976 | + cl = drawclient(c); | |
| 977 | + incref(&cl->r); | |
| 978 | + break; | |
| 979 | + } | |
| 980 | + qunlock(&sdraw.lk); | |
| 981 | + poperror(); | |
| 982 | + c->mode = openmode(omode); | |
| 983 | + c->flag |= COPEN; | |
| 984 | + c->offset = 0; | |
| 985 | + c->iounit = IOUNIT; | |
| 986 | + return c; | |
| 987 | +} | |
| 988 | + | |
| 989 | +static void | |
| 990 | +drawclose(Chan *c) | |
| 991 | +{ | |
| 992 | + int i; | |
| 993 | + DImage *d, **dp; | |
| 994 | + Client *cl; | |
| 995 | + Refresh *r; | |
| 996 | + | |
| 997 | + if(QID(c->qid) < Qcolormap) /* Qtopdir, Qnew, Q3rd, Q2nd have no client */ | |
| 998 | + return; | |
| 999 | + qlock(&sdraw.lk); | |
| 1000 | + if(waserror()){ | |
| 1001 | + qunlock(&sdraw.lk); | |
| 1002 | + nexterror(); | |
| 1003 | + } | |
| 1004 | + | |
| 1005 | + cl = drawclient(c); | |
| 1006 | + if(QID(c->qid) == Qctl) | |
| 1007 | + cl->busy = 0; | |
| 1008 | + if((c->flag&COPEN) && (decref(&cl->r)==0)){ | |
| 1009 | + while(r = cl->refresh){ /* assign = */ | |
| 1010 | + cl->refresh = r->next; | |
| 1011 | + free(r); | |
| 1012 | + } | |
| 1013 | + /* free names */ | |
| 1014 | + for(i=0; i<sdraw.nname; ) | |
| 1015 | + if(sdraw.name[i].client == cl) | |
| 1016 | + drawdelname(sdraw.name+i); | |
| 1017 | + else | |
| 1018 | + i++; | |
| 1019 | + while(cl->cscreen) | |
| 1020 | + drawuninstallscreen(cl, cl->cscreen); | |
| 1021 | + /* all screens are freed, so now we can free images */ | |
| 1022 | + dp = cl->dimage; | |
| 1023 | + for(i=0; i<NHASH; i++){ | |
| 1024 | + while((d = *dp) != nil){ | |
| 1025 | + *dp = d->next; | |
| 1026 | + drawfreedimage(d); | |
| 1027 | + } | |
| 1028 | + dp++; | |
| 1029 | + } | |
| 1030 | + sdraw.client[cl->slot] = 0; | |
| 1031 | + drawflush(); /* to erase visible, now dead windows */ | |
| 1032 | + free(cl); | |
| 1033 | + } | |
| 1034 | + qunlock(&sdraw.lk); | |
| 1035 | + poperror(); | |
| 1036 | +} | |
| 1037 | + | |
| 1038 | +long | |
| 1039 | +drawread(Chan *c, void *a, long n, vlong off) | |
| 1040 | +{ | |
| 1041 | + int index, m; | |
| 1042 | + ulong red, green, blue; | |
| 1043 | + Client *cl; | |
| 1044 | + uchar *p; | |
| 1045 | + Refresh *r; | |
| 1046 | + DImage *di; | |
| 1047 | + Memimage *i; | |
| 1048 | + ulong offset = off; | |
| 1049 | + char buf[16]; | |
| 1050 | + | |
| 1051 | + if(c->qid.type & QTDIR) | |
| 1052 | + return devdirread(c, a, n, 0, 0, drawgen); | |
| 1053 | + cl = drawclient(c); | |
| 1054 | + qlock(&sdraw.lk); | |
| 1055 | + if(waserror()){ | |
| 1056 | + qunlock(&sdraw.lk); | |
| 1057 | + nexterror(); | |
| 1058 | + } | |
| 1059 | + switch(QID(c->qid)){ | |
| 1060 | + case Qctl: | |
| 1061 | + if(n < 12*12) | |
| 1062 | + error(Eshortread); | |
| 1063 | + if(cl->infoid < 0) | |
| 1064 | + error(Enodrawimage); | |
| 1065 | + if(cl->infoid == 0){ | |
| 1066 | + i = screenimage; | |
| 1067 | + if(i == nil) | |
| 1068 | + error(Enodrawimage); | |
| 1069 | + }else{ | |
| 1070 | + di = drawlookup(cl, cl->infoid, 1); | |
| 1071 | + if(di == nil) | |
| 1072 | + error(Enodrawimage); | |
| 1073 | + i = di->image; | |
| 1074 | + } | |
| 1075 | + n = sprint(a, "%11d %11d %11s %11d %11d %11d %11d %11d %11d %11d %11d %11d ", | |
| 1076 | + cl->clientid, cl->infoid, chantostr(buf, i->chan), (i->flags&Frepl)==Frepl, | |
| 1077 | + i->r.min.x, i->r.min.y, i->r.max.x, i->r.max.y, | |
| 1078 | + i->clipr.min.x, i->clipr.min.y, i->clipr.max.x, i->clipr.max.y); | |
| 1079 | + cl->infoid = -1; | |
| 1080 | + break; | |
| 1081 | + | |
| 1082 | + case Qcolormap: | |
| 1083 | + drawactive(1); /* to restore map from backup */ | |
| 1084 | + p = malloc(4*12*256+1); | |
| 1085 | + if(p == 0) | |
| 1086 | + error(Enomem); | |
| 1087 | + m = 0; | |
| 1088 | + for(index = 0; index < 256; index++){ | |
| 1089 | + getcolor(index, &red, &green, &blue); | |
| 1090 | + m += sprint((char*)p+m, "%11d %11lud %11lud %11lud\n", index, red>>24, green>>24, blue>>24); | |
| 1091 | + } | |
| 1092 | + n = readstr(offset, a, n, (char*)p); | |
| 1093 | + free(p); | |
| 1094 | + break; | |
| 1095 | + | |
| 1096 | + case Qdata: | |
| 1097 | + if(cl->readdata == nil) | |
| 1098 | + error("no draw data"); | |
| 1099 | + if(n < cl->nreaddata) | |
| 1100 | + error(Eshortread); | |
| 1101 | + n = cl->nreaddata; | |
| 1102 | + memmove(a, cl->readdata, cl->nreaddata); | |
| 1103 | + free(cl->readdata); | |
| 1104 | + cl->readdata = nil; | |
| 1105 | + break; | |
| 1106 | + | |
| 1107 | + case Qrefresh: | |
| 1108 | + if(n < 5*4) | |
| 1109 | + error(Ebadarg); | |
| 1110 | + for(;;){ | |
| 1111 | + if(cl->refreshme || cl->refresh) | |
| 1112 | + break; | |
| 1113 | + qunlock(&sdraw.lk); | |
| 1114 | + if(waserror()){ | |
| 1115 | + qlock(&sdraw.lk); /* restore lock for waserror() above */ | |
| 1116 | + nexterror(); | |
| 1117 | + } | |
| 1118 | + sleep(&cl->refrend, drawrefactive, cl); | |
| 1119 | + poperror(); | |
| 1120 | + qlock(&sdraw.lk); | |
| 1121 | + } | |
| 1122 | + p = a; | |
| 1123 | + while(cl->refresh && n>=5*4){ | |
| 1124 | + r = cl->refresh; | |
| 1125 | + BPLONG(p+0*4, r->dimage->id); | |
| 1126 | + BPLONG(p+1*4, r->r.min.x); | |
| 1127 | + BPLONG(p+2*4, r->r.min.y); | |
| 1128 | + BPLONG(p+3*4, r->r.max.x); | |
| 1129 | + BPLONG(p+4*4, r->r.max.y); | |
| 1130 | + cl->refresh = r->next; | |
| 1131 | + free(r); | |
| 1132 | + p += 5*4; | |
| 1133 | + n -= 5*4; | |
| 1134 | + } | |
| 1135 | + cl->refreshme = 0; | |
| 1136 | + n = p-(uchar*)a; | |
| 1137 | + } | |
| 1138 | + qunlock(&sdraw.lk); | |
| 1139 | + poperror(); | |
| 1140 | + return n; | |
| 1141 | +} | |
| 1142 | + | |
| 1143 | +void | |
| 1144 | +drawwakeall(void) | |
| 1145 | +{ | |
| 1146 | + Client *cl; | |
| 1147 | + int i; | |
| 1148 | + | |
| 1149 | + for(i=0; i<sdraw.nclient; i++){ | |
| 1150 | + cl = sdraw.client[i]; | |
| 1151 | + if(cl && (cl->refreshme || cl->refresh)) | |
| 1152 | + wakeup(&cl->refrend); | |
| 1153 | + } | |
| 1154 | +} | |
| 1155 | + | |
| 1156 | +static long | |
| 1157 | +drawwrite(Chan *c, void *a, long n, vlong offset) | |
| 1158 | +{ | |
| 1159 | + char buf[128], *fields[4], *q; | |
| 1160 | + Client *cl; | |
| 1161 | + int i, m, red, green, blue, x; | |
| 1162 | + | |
| 1163 | + USED(offset); | |
| 1164 | + | |
| 1165 | + if(c->qid.type & QTDIR) | |
| 1166 | + error(Eisdir); | |
| 1167 | + cl = drawclient(c); | |
| 1168 | + qlock(&sdraw.lk); | |
| 1169 | + if(waserror()){ | |
| 1170 | + drawwakeall(); | |
| 1171 | + qunlock(&sdraw.lk); | |
| 1172 | + nexterror(); | |
| 1173 | + } | |
| 1174 | + switch(QID(c->qid)){ | |
| 1175 | + case Qctl: | |
| 1176 | + if(n != 4) | |
| 1177 | + error("unknown draw control request"); | |
| 1178 | + cl->infoid = BGLONG((uchar*)a); | |
| 1179 | + break; | |
| 1180 | + | |
| 1181 | + case Qcolormap: | |
| 1182 | + drawactive(1); /* to restore map from backup */ | |
| 1183 | + m = n; | |
| 1184 | + n = 0; | |
| 1185 | + while(m > 0){ | |
| 1186 | + x = m; | |
| 1187 | + if(x > sizeof(buf)-1) | |
| 1188 | + x = sizeof(buf)-1; | |
| 1189 | + q = memccpy(buf, a, '\n', x); | |
| 1190 | + if(q == 0) | |
| 1191 | + break; | |
| 1192 | + i = q-buf; | |
| 1193 | + n += i; | |
| 1194 | + a = (char*)a + i; | |
| 1195 | + m -= i; | |
| 1196 | + *q = 0; | |
| 1197 | + if(tokenize(buf, fields, nelem(fields)) != 4) | |
| 1198 | + error(Ebadarg); | |
| 1199 | + i = strtoul(fields[0], 0, 0); | |
| 1200 | + red = strtoul(fields[1], 0, 0); | |
| 1201 | + green = strtoul(fields[2], 0, 0); | |
| 1202 | + blue = strtoul(fields[3], &q, 0); | |
| 1203 | + if(fields[3] == q) | |
| 1204 | + error(Ebadarg); | |
| 1205 | + if(red>255 || green>255 || blue>255 || i<0 || i>255) | |
| 1206 | + error(Ebadarg); | |
| 1207 | + red |= red<<8; | |
| 1208 | + red |= red<<16; | |
| 1209 | + green |= green<<8; | |
| 1210 | + green |= green<<16; | |
| 1211 | + blue |= blue<<8; | |
| 1212 | + blue |= blue<<16; | |
| 1213 | + setcolor(i, red, green, blue); | |
| 1214 | + } | |
| 1215 | + break; | |
| 1216 | + | |
| 1217 | + case Qdata: | |
| 1218 | + drawmesg(cl, a, n); | |
| 1219 | + drawwakeall(); | |
| 1220 | + break; | |
| 1221 | + | |
| 1222 | + default: | |
| 1223 | + error(Ebadusefd); | |
| 1224 | + } | |
| 1225 | + qunlock(&sdraw.lk); | |
| 1226 | + poperror(); | |
| 1227 | + return n; | |
| 1228 | +} | |
| 1229 | + | |
| 1230 | +uchar* | |
| 1231 | +drawcoord(uchar *p, uchar *maxp, int oldx, int *newx) | |
| 1232 | +{ | |
| 1233 | + int b, x; | |
| 1234 | + | |
| 1235 | + if(p >= maxp) | |
| 1236 | + error(Eshortdraw); | |
| 1237 | + b = *p++; | |
| 1238 | + x = b & 0x7F; | |
| 1239 | + if(b & 0x80){ | |
| 1240 | + if(p+1 >= maxp) | |
| 1241 | + error(Eshortdraw); | |
| 1242 | + x |= *p++ << 7; | |
| 1243 | + x |= *p++ << 15; | |
| 1244 | + if(x & (1<<22)) | |
| 1245 | + x |= ~0<<23; | |
| 1246 | + }else{ | |
| 1247 | + if(b & 0x40) | |
| 1248 | + x |= ~0<<7; | |
| 1249 | + x += oldx; | |
| 1250 | + } | |
| 1251 | + *newx = x; | |
| 1252 | + return p; | |
| 1253 | +} | |
| 1254 | + | |
| 1255 | +static void | |
| 1256 | +printmesg(char *fmt, uchar *a, int plsprnt) | |
| 1257 | +{ | |
| 1258 | + char buf[256]; | |
| 1259 | + char *p, *q; | |
| 1260 | + int s; | |
| 1261 | + | |
| 1262 | + if(1|| plsprnt==0){ | |
| 1263 | + SET(s); | |
| 1264 | + SET(q); | |
| 1265 | + SET(p); | |
| 1266 | + USED(fmt); | |
| 1267 | + USED(a); | |
| 1268 | + USED(buf); | |
| 1269 | + USED(p); | |
| 1270 | + USED(q); | |
| 1271 | + USED(s); | |
| 1272 | + return; | |
| 1273 | + } | |
| 1274 | + q = buf; | |
| 1275 | + *q++ = *a++; | |
| 1276 | + for(p=fmt; *p; p++){ | |
| 1277 | + switch(*p){ | |
| 1278 | + case 'l': | |
| 1279 | + q += sprint(q, " %ld", (long)BGLONG(a)); | |
| 1280 | + a += 4; | |
| 1281 | + break; | |
| 1282 | + case 'L': | |
| 1283 | + q += sprint(q, " %.8lux", (ulong)BGLONG(a)); | |
| 1284 | + a += 4; | |
| 1285 | + break; | |
| 1286 | + case 'R': | |
| 1287 | + q += sprint(q, " [%d %d %d %d]", BGLONG(a), BGLONG(a+4), BGLONG(a+8), BGLONG(a+12)); | |
| 1288 | + a += 16; | |
| 1289 | + break; | |
| 1290 | + case 'P': | |
| 1291 | + q += sprint(q, " [%d %d]", BGLONG(a), BGLONG(a+4)); | |
| 1292 | + a += 8; | |
| 1293 | + break; | |
| 1294 | + case 'b': | |
| 1295 | + q += sprint(q, " %d", *a++); | |
| 1296 | + break; | |
| 1297 | + case 's': | |
| 1298 | + q += sprint(q, " %d", BGSHORT(a)); | |
| 1299 | + a += 2; | |
| 1300 | + break; | |
| 1301 | + case 'S': | |
| 1302 | + q += sprint(q, " %.4ux", BGSHORT(a)); | |
| 1303 | + a += 2; | |
| 1304 | + break; | |
| 1305 | + } | |
| 1306 | + } | |
| 1307 | + *q++ = '\n'; | |
| 1308 | + *q = 0; | |
| 1309 | + iprint("%.*s", (int)(q-buf), buf); | |
| 1310 | +} | |
| 1311 | + | |
| 1312 | +void | |
| 1313 | +drawmesg(Client *client, void *av, int n) | |
| 1314 | +{ | |
| 1315 | + int c, repl, m, y, dstid, scrnid, ni, ci, j, nw, e0, e1, op, ox, oy, oesize, esize, doflush; | |
| 1316 | + uchar *u, *a, refresh; | |
| 1317 | + char *fmt; | |
| 1318 | + ulong value, chan; | |
| 1319 | + Rectangle r, clipr; | |
| 1320 | + Point p, q, *pp, sp; | |
| 1321 | + Memimage *i, *dst, *src, *mask; | |
| 1322 | + Memimage *l, **lp; | |
| 1323 | + Memscreen *scrn; | |
| 1324 | + DImage *font, *ll, *di, *ddst, *dsrc; | |
| 1325 | + DName *dn; | |
| 1326 | + DScreen *dscrn; | |
| 1327 | + FChar *fc; | |
| 1328 | + Refx *refx; | |
| 1329 | + CScreen *cs; | |
| 1330 | + Refreshfn reffn; | |
| 1331 | + | |
| 1332 | + a = av; | |
| 1333 | + m = 0; | |
| 1334 | + fmt = nil; | |
| 1335 | + if(waserror()){ | |
| 1336 | + if(fmt) printmesg(fmt, a, 1); | |
| 1337 | + /* iprint("error: %s\n", up->errstr); */ | |
| 1338 | + nexterror(); | |
| 1339 | + } | |
| 1340 | + while((n-=m) > 0){ | |
| 1341 | + USED(fmt); | |
| 1342 | + a += m; | |
| 1343 | + switch(*a){ | |
| 1344 | + default: | |
| 1345 | + error("bad draw command"); | |
| 1346 | + /* new allocate: 'b' id[4] screenid[4] refresh[1] chan[4] repl[1] R[4*4] clipR[4*4] rrggbbaa[4] */ | |
| 1347 | + case 'b': | |
| 1348 | + printmesg(fmt="LLbLbRRL", a, 0); | |
| 1349 | + m = 1+4+4+1+4+1+4*4+4*4+4; | |
| 1350 | + if(n < m) | |
| 1351 | + error(Eshortdraw); | |
| 1352 | + dstid = BGLONG(a+1); | |
| 1353 | + scrnid = BGSHORT(a+5); | |
| 1354 | + refresh = a[9]; | |
| 1355 | + chan = BGLONG(a+10); | |
| 1356 | + repl = a[14]; | |
| 1357 | + drawrectangle(&r, a+15); | |
| 1358 | + drawrectangle(&clipr, a+31); | |
| 1359 | + value = BGLONG(a+47); | |
| 1360 | + if(drawlookup(client, dstid, 0)) | |
| 1361 | + error(Eimageexists); | |
| 1362 | + if(scrnid){ | |
| 1363 | + dscrn = drawlookupscreen(client, scrnid, &cs); | |
| 1364 | + scrn = dscrn->screen; | |
| 1365 | + if(repl || chan!=scrn->image->chan) | |
| 1366 | + error("image parameters incompatible with screen"); | |
| 1367 | + reffn = nil; | |
| 1368 | + switch(refresh){ | |
| 1369 | + case Refbackup: | |
| 1370 | + break; | |
| 1371 | + case Refnone: | |
| 1372 | + reffn = memlnorefresh; | |
| 1373 | + break; | |
| 1374 | + case Refmesg: | |
| 1375 | + reffn = drawrefresh; | |
| 1376 | + break; | |
| 1377 | + default: | |
| 1378 | + error("unknown refresh method"); | |
| 1379 | + } | |
| 1380 | + l = memlalloc(scrn, r, reffn, 0, value); | |
| 1381 | + if(l == 0) | |
| 1382 | + error(Edrawmem); | |
| 1383 | + addflush(l->layer->screenr); | |
| 1384 | + l->clipr = clipr; | |
| 1385 | + rectclip(&l->clipr, r); | |
| 1386 | + if(drawinstall(client, dstid, l, dscrn) == 0){ | |
| 1387 | + memldelete(l); | |
| 1388 | + error(Edrawmem); | |
| 1389 | + } | |
| 1390 | + dscrn->ref++; | |
| 1391 | + if(reffn){ | |
| 1392 | + refx = nil; | |
| 1393 | + if(reffn == drawrefresh){ | |
| 1394 | + refx = malloc(sizeof(Refx)); | |
| 1395 | + if(refx == 0){ | |
| 1396 | + drawuninstall(client, dstid); | |
| 1397 | + error(Edrawmem); | |
| 1398 | + } | |
| 1399 | + refx->client = client; | |
| 1400 | + refx->dimage = drawlookup(client, dstid, 1); | |
| 1401 | + } | |
| 1402 | + memlsetrefresh(l, reffn, refx); | |
| 1403 | + } | |
| 1404 | + continue; | |
| 1405 | + } | |
| 1406 | + i = allocmemimage(r, chan); | |
| 1407 | + if(i == 0) | |
| 1408 | + error(Edrawmem); | |
| 1409 | + if(repl) | |
| 1410 | + i->flags |= Frepl; | |
| 1411 | + i->clipr = clipr; | |
| 1412 | + if(!repl) | |
| 1413 | + rectclip(&i->clipr, r); | |
| 1414 | + if(drawinstall(client, dstid, i, 0) == 0){ | |
| 1415 | + freememimage(i); | |
| 1416 | + error(Edrawmem); | |
| 1417 | + } | |
| 1418 | + memfillcolor(i, value); | |
| 1419 | + continue; | |
| 1420 | + | |
| 1421 | + /* allocate screen: 'A' id[4] imageid[4] fillid[4] public[1] */ | |
| 1422 | + case 'A': | |
| 1423 | + printmesg(fmt="LLLb", a, 1); | |
| 1424 | + m = 1+4+4+4+1; | |
| 1425 | + if(n < m) | |
| 1426 | + error(Eshortdraw); | |
| 1427 | + dstid = BGLONG(a+1); | |
| 1428 | + if(dstid == 0) | |
| 1429 | + error(Ebadarg); | |
| 1430 | + if(drawlookupdscreen(dstid)) | |
| 1431 | + error(Escreenexists); | |
| 1432 | + ddst = drawlookup(client, BGLONG(a+5), 1); | |
| 1433 | + dsrc = drawlookup(client, BGLONG(a+9), 1); | |
| 1434 | + if(ddst==0 || dsrc==0) | |
| 1435 | + error(Enodrawimage); | |
| 1436 | + if(drawinstallscreen(client, 0, dstid, ddst, dsrc, a[13]) == 0) | |
| 1437 | + error(Edrawmem); | |
| 1438 | + continue; | |
| 1439 | + | |
| 1440 | + /* set repl and clip: 'c' dstid[4] repl[1] clipR[4*4] */ | |
| 1441 | + case 'c': | |
| 1442 | + printmesg(fmt="LbR", a, 0); | |
| 1443 | + m = 1+4+1+4*4; | |
| 1444 | + if(n < m) | |
| 1445 | + error(Eshortdraw); | |
| 1446 | + ddst = drawlookup(client, BGLONG(a+1), 1); | |
| 1447 | + if(ddst == nil) | |
| 1448 | + error(Enodrawimage); | |
| 1449 | + if(ddst->name) | |
| 1450 | + error("can't change repl/clipr of shared image"); | |
| 1451 | + dst = ddst->image; | |
| 1452 | + if(a[5]) | |
| 1453 | + dst->flags |= Frepl; | |
| 1454 | + drawrectangle(&dst->clipr, a+6); | |
| 1455 | + continue; | |
| 1456 | + | |
| 1457 | + /* draw: 'd' dstid[4] srcid[4] maskid[4] R[4*4] P[2*4] P[2*4] */ | |
| 1458 | + case 'd': | |
| 1459 | + printmesg(fmt="LLLRPP", a, 0); | |
| 1460 | + m = 1+4+4+4+4*4+2*4+2*4; | |
| 1461 | + if(n < m) | |
| 1462 | + error(Eshortdraw); | |
| 1463 | + dst = drawimage(client, a+1); | |
| 1464 | + dstid = BGLONG(a+1); | |
| 1465 | + src = drawimage(client, a+5); | |
| 1466 | + mask = drawimage(client, a+9); | |
| 1467 | + drawrectangle(&r, a+13); | |
| 1468 | + drawpoint(&p, a+29); | |
| 1469 | + drawpoint(&q, a+37); | |
| 1470 | + op = drawclientop(client); | |
| 1471 | + memdraw(dst, r, src, p, mask, q, op); | |
| 1472 | + dstflush(dstid, dst, r); | |
| 1473 | + continue; | |
| 1474 | + | |
| 1475 | + /* toggle debugging: 'D' val[1] */ | |
| 1476 | + case 'D': | |
| 1477 | + printmesg(fmt="b", a, 0); | |
| 1478 | + m = 1+1; | |
| 1479 | + if(n < m) | |
| 1480 | + error(Eshortdraw); | |
| 1481 | + drawdebug = a[1]; | |
| 1482 | + continue; | |
| 1483 | + | |
| 1484 | + /* ellipse: 'e' dstid[4] srcid[4] center[2*4] a[4] b[4] thick[4] sp[2*4] alpha[4] phi[4]*/ | |
| 1485 | + case 'e': | |
| 1486 | + case 'E': | |
| 1487 | + printmesg(fmt="LLPlllPll", a, 0); | |
| 1488 | + m = 1+4+4+2*4+4+4+4+2*4+2*4; | |
| 1489 | + if(n < m) | |
| 1490 | + error(Eshortdraw); | |
| 1491 | + dst = drawimage(client, a+1); | |
| 1492 | + dstid = BGLONG(a+1); | |
| 1493 | + src = drawimage(client, a+5); | |
| 1494 | + drawpoint(&p, a+9); | |
| 1495 | + e0 = BGLONG(a+17); | |
| 1496 | + e1 = BGLONG(a+21); | |
| 1497 | + if(e0<0 || e1<0) | |
| 1498 | + error("invalid ellipse semidiameter"); | |
| 1499 | + j = BGLONG(a+25); | |
| 1500 | + if(j < 0) | |
| 1501 | + error("negative ellipse thickness"); | |
| 1502 | + drawpoint(&sp, a+29); | |
| 1503 | + c = j; | |
| 1504 | + if(*a == 'E') | |
| 1505 | + c = -1; | |
| 1506 | + ox = BGLONG(a+37); | |
| 1507 | + oy = BGLONG(a+41); | |
| 1508 | + op = drawclientop(client); | |
| 1509 | + /* high bit indicates arc angles are present */ | |
| 1510 | + if(ox & (1<<31)){ | |
| 1511 | + if((ox & (1<<30)) == 0) | |
| 1512 | + ox &= ~(1<<31); | |
| 1513 | + memarc(dst, p, e0, e1, c, src, sp, ox, oy, op); | |
| 1514 | + }else | |
| 1515 | + memellipse(dst, p, e0, e1, c, src, sp, op); | |
| 1516 | + dstflush(dstid, dst, Rect(p.x-e0-j, p.y-e1-j, p.x+e0+j+1, p.y+e1+j+1)); | |
| 1517 | + continue; | |
| 1518 | + | |
| 1519 | + /* free: 'f' id[4] */ | |
| 1520 | + case 'f': | |
| 1521 | + printmesg(fmt="L", a, 1); | |
| 1522 | + m = 1+4; | |
| 1523 | + if(n < m) | |
| 1524 | + error(Eshortdraw); | |
| 1525 | + ll = drawlookup(client, BGLONG(a+1), 0); | |
| 1526 | + if(ll && ll->dscreen && ll->dscreen->owner != client) | |
| 1527 | + ll->dscreen->owner->refreshme = 1; | |
| 1528 | + drawuninstall(client, BGLONG(a+1)); | |
| 1529 | + continue; | |
| 1530 | + | |
| 1531 | + /* free screen: 'F' id[4] */ | |
| 1532 | + case 'F': | |
| 1533 | + printmesg(fmt="L", a, 1); | |
| 1534 | + m = 1+4; | |
| 1535 | + if(n < m) | |
| 1536 | + error(Eshortdraw); | |
| 1537 | + drawlookupscreen(client, BGLONG(a+1), &cs); | |
| 1538 | + drawuninstallscreen(client, cs); | |
| 1539 | + continue; | |
| 1540 | + | |
| 1541 | + /* initialize font: 'i' fontid[4] nchars[4] ascent[1] */ | |
| 1542 | + case 'i': | |
| 1543 | + printmesg(fmt="Llb", a, 1); | |
| 1544 | + m = 1+4+4+1; | |
| 1545 | + if(n < m) | |
| 1546 | + error(Eshortdraw); | |
| 1547 | + dstid = BGLONG(a+1); | |
| 1548 | + if(dstid == 0) | |
| 1549 | + error("can't use display as font"); | |
| 1550 | + font = drawlookup(client, dstid, 1); | |
| 1551 | + if(font == 0) | |
| 1552 | + error(Enodrawimage); | |
| 1553 | + if(font->image->layer) | |
| 1554 | + error("can't use window as font"); | |
| 1555 | + ni = BGLONG(a+5); | |
| 1556 | + if(ni<=0 || ni>4096) | |
| 1557 | + error("bad font size (4096 chars max)"); | |
| 1558 | + free(font->fchar); /* should we complain if non-zero? */ | |
| 1559 | + font->fchar = malloc(ni*sizeof(FChar)); | |
| 1560 | + if(font->fchar == 0) | |
| 1561 | + error("no memory for font"); | |
| 1562 | + memset(font->fchar, 0, ni*sizeof(FChar)); | |
| 1563 | + font->nfchar = ni; | |
| 1564 | + font->ascent = a[9]; | |
| 1565 | + continue; | |
| 1566 | + | |
| 1567 | + /* load character: 'l' fontid[4] srcid[4] index[2] R[4*4] P[2*4] left[1] width[1] */ | |
| 1568 | + case 'l': | |
| 1569 | + printmesg(fmt="LLSRPbb", a, 0); | |
| 1570 | + m = 1+4+4+2+4*4+2*4+1+1; | |
| 1571 | + if(n < m) | |
| 1572 | + error(Eshortdraw); | |
| 1573 | + font = drawlookup(client, BGLONG(a+1), 1); | |
| 1574 | + if(font == 0) | |
| 1575 | + error(Enodrawimage); | |
| 1576 | + if(font->nfchar == 0) | |
| 1577 | + error(Enotfont); | |
| 1578 | + src = drawimage(client, a+5); | |
| 1579 | + ci = BGSHORT(a+9); | |
| 1580 | + if(ci >= font->nfchar) | |
| 1581 | + error(Eindex); | |
| 1582 | + drawrectangle(&r, a+11); | |
| 1583 | + drawpoint(&p, a+27); | |
| 1584 | + memdraw(font->image, r, src, p, memopaque, p, S); | |
| 1585 | + fc = &font->fchar[ci]; | |
| 1586 | + fc->minx = r.min.x; | |
| 1587 | + fc->maxx = r.max.x; | |
| 1588 | + fc->miny = r.min.y; | |
| 1589 | + fc->maxy = r.max.y; | |
| 1590 | + fc->left = a[35]; | |
| 1591 | + fc->width = a[36]; | |
| 1592 | + continue; | |
| 1593 | + | |
| 1594 | + /* draw line: 'L' dstid[4] p0[2*4] p1[2*4] end0[4] end1[4] radius[4] srcid[4] sp[2*4] */ | |
| 1595 | + case 'L': | |
| 1596 | + printmesg(fmt="LPPlllLP", a, 0); | |
| 1597 | + m = 1+4+2*4+2*4+4+4+4+4+2*4; | |
| 1598 | + if(n < m) | |
| 1599 | + error(Eshortdraw); | |
| 1600 | + dst = drawimage(client, a+1); | |
| 1601 | + dstid = BGLONG(a+1); | |
| 1602 | + drawpoint(&p, a+5); | |
| 1603 | + drawpoint(&q, a+13); | |
| 1604 | + e0 = BGLONG(a+21); | |
| 1605 | + e1 = BGLONG(a+25); | |
| 1606 | + j = BGLONG(a+29); | |
| 1607 | + if(j < 0) | |
| 1608 | + error("negative line width"); | |
| 1609 | + src = drawimage(client, a+33); | |
| 1610 | + drawpoint(&sp, a+37); | |
| 1611 | + op = drawclientop(client); | |
| 1612 | + memline(dst, p, q, e0, e1, j, src, sp, op); | |
| 1613 | + /* avoid memlinebbox if possible */ | |
| 1614 | + if(dstid==0 || dst->layer!=nil){ | |
| 1615 | + /* BUG: this is terribly inefficient: update maximal containing rect*/ | |
| 1616 | + r = memlinebbox(p, q, e0, e1, j); | |
| 1617 | + dstflush(dstid, dst, insetrect(r, -(1+1+j))); | |
| 1618 | + } | |
| 1619 | + continue; | |
| 1620 | + | |
| 1621 | + /* create image mask: 'm' newid[4] id[4] */ | |
| 1622 | +/* | |
| 1623 | + * | |
| 1624 | + case 'm': | |
| 1625 | + printmesg("LL", a, 0); | |
| 1626 | + m = 4+4; | |
| 1627 | + if(n < m) | |
| 1628 | + error(Eshortdraw); | |
| 1629 | + break; | |
| 1630 | + * | |
| 1631 | + */ | |
| 1632 | + | |
| 1633 | + /* attach to a named image: 'n' dstid[4] j[1] name[j] */ | |
| 1634 | + case 'n': | |
| 1635 | + printmesg(fmt="Lz", a, 0); | |
| 1636 | + m = 1+4+1; | |
| 1637 | + if(n < m) | |
| 1638 | + error(Eshortdraw); | |
| 1639 | + j = a[5]; | |
| 1640 | + if(j == 0) /* give me a non-empty name please */ | |
| 1641 | + error(Eshortdraw); | |
| 1642 | + m += j; | |
| 1643 | + if(n < m) | |
| 1644 | + error(Eshortdraw); | |
| 1645 | + dstid = BGLONG(a+1); | |
| 1646 | + if(drawlookup(client, dstid, 0)) | |
| 1647 | + error(Eimageexists); | |
| 1648 | + dn = drawlookupname(j, (char*)a+6); | |
| 1649 | + if(dn == nil) | |
| 1650 | + error(Enoname); | |
| 1651 | + if(drawinstall(client, dstid, dn->dimage->image, 0) == 0) | |
| 1652 | + error(Edrawmem); | |
| 1653 | + di = drawlookup(client, dstid, 0); | |
| 1654 | + if(di == 0) | |
| 1655 | + error("draw: can't happen"); | |
| 1656 | + di->vers = dn->vers; | |
| 1657 | + di->name = smalloc(j+1); | |
| 1658 | + di->fromname = dn->dimage; | |
| 1659 | + di->fromname->ref++; | |
| 1660 | + memmove(di->name, a+6, j); | |
| 1661 | + di->name[j] = 0; | |
| 1662 | + client->infoid = dstid; | |
| 1663 | + continue; | |
| 1664 | + | |
| 1665 | + /* name an image: 'N' dstid[4] in[1] j[1] name[j] */ | |
| 1666 | + case 'N': | |
| 1667 | + printmesg(fmt="Lbz", a, 0); | |
| 1668 | + m = 1+4+1+1; | |
| 1669 | + if(n < m) | |
| 1670 | + error(Eshortdraw); | |
| 1671 | + c = a[5]; | |
| 1672 | + j = a[6]; | |
| 1673 | + if(j == 0) /* give me a non-empty name please */ | |
| 1674 | + error(Eshortdraw); | |
| 1675 | + m += j; | |
| 1676 | + if(n < m) | |
| 1677 | + error(Eshortdraw); | |
| 1678 | + di = drawlookup(client, BGLONG(a+1), 0); | |
| 1679 | + if(di == 0) | |
| 1680 | + error(Enodrawimage); | |
| 1681 | + if(di->name) | |
| 1682 | + error(Enamed); | |
| 1683 | + if(c) | |
| 1684 | + drawaddname(client, di, j, (char*)a+7); | |
| 1685 | + else{ | |
| 1686 | + dn = drawlookupname(j, (char*)a+7); | |
| 1687 | + if(dn == nil) | |
| 1688 | + error(Enoname); | |
| 1689 | + if(dn->dimage != di) | |
| 1690 | + error(Ewrongname); | |
| 1691 | + drawdelname(dn); | |
| 1692 | + } | |
| 1693 | + continue; | |
| 1694 | + | |
| 1695 | + /* position window: 'o' id[4] r.min [2*4] screenr.min [2*4] */ | |
| 1696 | + case 'o': | |
| 1697 | + printmesg(fmt="LPP", a, 0); | |
| 1698 | + m = 1+4+2*4+2*4; | |
| 1699 | + if(n < m) | |
| 1700 | + error(Eshortdraw); | |
| 1701 | + dst = drawimage(client, a+1); | |
| 1702 | + if(dst->layer){ | |
| 1703 | + drawpoint(&p, a+5); | |
| 1704 | + drawpoint(&q, a+13); | |
| 1705 | + r = dst->layer->screenr; | |
| 1706 | + ni = memlorigin(dst, p, q); | |
| 1707 | + if(ni < 0) | |
| 1708 | + error("image origin failed"); | |
| 1709 | + if(ni > 0){ | |
| 1710 | + addflush(r); | |
| 1711 | + addflush(dst->layer->screenr); | |
| 1712 | + ll = drawlookup(client, BGLONG(a+1), 1); | |
| 1713 | + drawrefreshscreen(ll, client); | |
| 1714 | + } | |
| 1715 | + } | |
| 1716 | + continue; | |
| 1717 | + | |
| 1718 | + /* set compositing operator for next draw operation: 'O' op */ | |
| 1719 | + case 'O': | |
| 1720 | + printmesg(fmt="b", a, 0); | |
| 1721 | + m = 1+1; | |
| 1722 | + if(n < m) | |
| 1723 | + error(Eshortdraw); | |
| 1724 | + client->op = a[1]; | |
| 1725 | + continue; | |
| 1726 | + | |
| 1727 | + /* filled polygon: 'P' dstid[4] n[2] wind[4] ignore[2*4] srcid[4] sp[2*4] p0[2*4] dp[2*2*n] */ | |
| 1728 | + /* polygon: 'p' dstid[4] n[2] end0[4] end1[4] radius[4] srcid[4] sp[2*4] p0[2*4] dp[2*2*n] */ | |
| 1729 | + case 'p': | |
| 1730 | + case 'P': | |
| 1731 | + printmesg(fmt="LslllLPP", a, 0); | |
| 1732 | + m = 1+4+2+4+4+4+4+2*4; | |
| 1733 | + if(n < m) | |
| 1734 | + error(Eshortdraw); | |
| 1735 | + dstid = BGLONG(a+1); | |
| 1736 | + dst = drawimage(client, a+1); | |
| 1737 | + ni = BGSHORT(a+5); | |
| 1738 | + if(ni < 0) | |
| 1739 | + error("negative count in polygon"); | |
| 1740 | + e0 = BGLONG(a+7); | |
| 1741 | + e1 = BGLONG(a+11); | |
| 1742 | + j = 0; | |
| 1743 | + if(*a == 'p'){ | |
| 1744 | + j = BGLONG(a+15); | |
| 1745 | + if(j < 0) | |
| 1746 | + error("negative polygon line width"); | |
| 1747 | + } | |
| 1748 | + src = drawimage(client, a+19); | |
| 1749 | + drawpoint(&sp, a+23); | |
| 1750 | + drawpoint(&p, a+31); | |
| 1751 | + ni++; | |
| 1752 | + pp = malloc(ni*sizeof(Point)); | |
| 1753 | + if(pp == nil) | |
| 1754 | + error(Enomem); | |
| 1755 | + doflush = 0; | |
| 1756 | + if(dstid==0 || (dst->layer && dst->layer->screen->image->data == screenimage->data)) | |
| 1757 | + doflush = 1; /* simplify test in loop */ | |
| 1758 | + ox = oy = 0; | |
| 1759 | + esize = 0; | |
| 1760 | + u = a+m; | |
| 1761 | + for(y=0; y<ni; y++){ | |
| 1762 | + q = p; | |
| 1763 | + oesize = esize; | |
| 1764 | + u = drawcoord(u, a+n, ox, &p.x); | |
| 1765 | + u = drawcoord(u, a+n, oy, &p.y); | |
| 1766 | + ox = p.x; | |
| 1767 | + oy = p.y; | |
| 1768 | + if(doflush){ | |
| 1769 | + esize = j; | |
| 1770 | + if(*a == 'p'){ | |
| 1771 | + if(y == 0){ | |
| 1772 | + c = memlineendsize(e0); | |
| 1773 | + if(c > esize) | |
| 1774 | + esize = c; | |
| 1775 | + } | |
| 1776 | + if(y == ni-1){ | |
| 1777 | + c = memlineendsize(e1); | |
| 1778 | + if(c > esize) | |
| 1779 | + esize = c; | |
| 1780 | + } | |
| 1781 | + } | |
| 1782 | + if(*a=='P' && e0!=1 && e0 !=~0) | |
| 1783 | + r = dst->clipr; | |
| 1784 | + else if(y > 0){ | |
| 1785 | + r = Rect(q.x-oesize, q.y-oesize, q.x+oesize+1, q.y+oesize+1); | |
| 1786 | + combinerect(&r, Rect(p.x-esize, p.y-esize, p.x+esize+1, p.y+esize+1)); | |
| 1787 | + } | |
| 1788 | + if(rectclip(&r, dst->clipr)) /* should perhaps be an arg to dstflush */ | |
| 1789 | + dstflush(dstid, dst, r); | |
| 1790 | + } | |
| 1791 | + pp[y] = p; | |
| 1792 | + } | |
| 1793 | + if(y == 1) | |
| 1794 | + dstflush(dstid, dst, Rect(p.x-esize, p.y-esize, p.x+esize+1, p.y+esize+1)); | |
| 1795 | + op = drawclientop(client); | |
| 1796 | + if(*a == 'p') | |
| 1797 | + mempoly(dst, pp, ni, e0, e1, j, src, sp, op); | |
| 1798 | + else | |
| 1799 | + memfillpoly(dst, pp, ni, e0, src, sp, op); | |
| 1800 | + free(pp); | |
| 1801 | + m = u-a; | |
| 1802 | + continue; | |
| 1803 | + | |
| 1804 | + /* read: 'r' id[4] R[4*4] */ | |
| 1805 | + case 'r': | |
| 1806 | + printmesg(fmt="LR", a, 0); | |
| 1807 | + m = 1+4+4*4; | |
| 1808 | + if(n < m) | |
| 1809 | + error(Eshortdraw); | |
| 1810 | + i = drawimage(client, a+1); | |
| 1811 | + drawrectangle(&r, a+5); | |
| 1812 | + if(!rectinrect(r, i->r)) | |
| 1813 | + error(Ereadoutside); | |
| 1814 | + c = bytesperline(r, i->depth); | |
| 1815 | + c *= Dy(r); | |
| 1816 | + free(client->readdata); | |
| 1817 | + client->readdata = mallocz(c, 0); | |
| 1818 | + if(client->readdata == nil) | |
| 1819 | + error("readimage malloc failed"); | |
| 1820 | + client->nreaddata = memunload(i, r, client->readdata, c); | |
| 1821 | + if(client->nreaddata < 0){ | |
| 1822 | + free(client->readdata); | |
| 1823 | + client->readdata = nil; | |
| 1824 | + error("bad readimage call"); | |
| 1825 | + } | |
| 1826 | + continue; | |
| 1827 | + | |
| 1828 | + /* string: 's' dstid[4] srcid[4] fontid[4] P[2*4] clipr[4*4] sp[2*4] ni[2] ni*(index[2]) */ | |
| 1829 | + /* stringbg: 'x' dstid[4] srcid[4] fontid[4] P[2*4] clipr[4*4] sp[2*4] ni[2] bgid[4] bgpt[2*4] ni*(index[2]) */ | |
| 1830 | + case 's': | |
| 1831 | + case 'x': | |
| 1832 | + printmesg(fmt="LLLPRPs", a, 0); | |
| 1833 | + m = 1+4+4+4+2*4+4*4+2*4+2; | |
| 1834 | + if(*a == 'x') | |
| 1835 | + m += 4+2*4; | |
| 1836 | + if(n < m) | |
| 1837 | + error(Eshortdraw); | |
| 1838 | + | |
| 1839 | + dst = drawimage(client, a+1); | |
| 1840 | + dstid = BGLONG(a+1); | |
| 1841 | + src = drawimage(client, a+5); | |
| 1842 | + font = drawlookup(client, BGLONG(a+9), 1); | |
| 1843 | + if(font == 0) | |
| 1844 | + error(Enodrawimage); | |
| 1845 | + if(font->nfchar == 0) | |
| 1846 | + error(Enotfont); | |
| 1847 | + drawpoint(&p, a+13); | |
| 1848 | + drawrectangle(&r, a+21); | |
| 1849 | + drawpoint(&sp, a+37); | |
| 1850 | + ni = BGSHORT(a+45); | |
| 1851 | + u = a+m; | |
| 1852 | + m += ni*2; | |
| 1853 | + if(n < m) | |
| 1854 | + error(Eshortdraw); | |
| 1855 | + clipr = dst->clipr; | |
| 1856 | + dst->clipr = r; | |
| 1857 | + op = drawclientop(client); | |
| 1858 | + if(*a == 'x'){ | |
| 1859 | + /* paint background */ | |
| 1860 | + l = drawimage(client, a+47); | |
| 1861 | + drawpoint(&q, a+51); | |
| 1862 | + r.min.x = p.x; | |
| 1863 | + r.min.y = p.y-font->ascent; | |
| 1864 | + r.max.x = p.x; | |
| 1865 | + r.max.y = r.min.y+Dy(font->image->r); | |
| 1866 | + j = ni; | |
| 1867 | + while(--j >= 0){ | |
| 1868 | + ci = BGSHORT(u); | |
| 1869 | + if(ci<0 || ci>=font->nfchar){ | |
| 1870 | + dst->clipr = clipr; | |
| 1871 | + error(Eindex); | |
| 1872 | + } | |
| 1873 | + r.max.x += font->fchar[ci].width; | |
| 1874 | + u += 2; | |
| 1875 | + } | |
| 1876 | + memdraw(dst, r, l, q, memopaque, ZP, op); | |
| 1877 | + u -= 2*ni; | |
| 1878 | + } | |
| 1879 | + q = p; | |
| 1880 | + while(--ni >= 0){ | |
| 1881 | + ci = BGSHORT(u); | |
| 1882 | + if(ci<0 || ci>=font->nfchar){ | |
| 1883 | + dst->clipr = clipr; | |
| 1884 | + error(Eindex); | |
| 1885 | + } | |
| 1886 | + q = drawchar(dst, q, src, &sp, font, ci, op); | |
| 1887 | + u += 2; | |
| 1888 | + } | |
| 1889 | + dst->clipr = clipr; | |
| 1890 | + p.y -= font->ascent; | |
| 1891 | + dstflush(dstid, dst, Rect(p.x, p.y, q.x, p.y+Dy(font->image->r))); | |
| 1892 | + continue; | |
| 1893 | + | |
| 1894 | + /* use public screen: 'S' id[4] chan[4] */ | |
| 1895 | + case 'S': | |
| 1896 | + printmesg(fmt="Ll", a, 0); | |
| 1897 | + m = 1+4+4; | |
| 1898 | + if(n < m) | |
| 1899 | + error(Eshortdraw); | |
| 1900 | + dstid = BGLONG(a+1); | |
| 1901 | + if(dstid == 0) | |
| 1902 | + error(Ebadarg); | |
| 1903 | + dscrn = drawlookupdscreen(dstid); | |
| 1904 | + if(dscrn==0 || (dscrn->public==0 && dscrn->owner!=client)) | |
| 1905 | + error(Enodrawscreen); | |
| 1906 | + if(dscrn->screen->image->chan != BGLONG(a+5)) | |
| 1907 | + error("inconsistent chan"); | |
| 1908 | + if(drawinstallscreen(client, dscrn, 0, 0, 0, 0) == 0) | |
| 1909 | + error(Edrawmem); | |
| 1910 | + continue; | |
| 1911 | + | |
| 1912 | + /* top or bottom windows: 't' top[1] nw[2] n*id[4] */ | |
| 1913 | + case 't': | |
| 1914 | + printmesg(fmt="bsL", a, 0); | |
| 1915 | + m = 1+1+2; | |
| 1916 | + if(n < m) | |
| 1917 | + error(Eshortdraw); | |
| 1918 | + nw = BGSHORT(a+2); | |
| 1919 | + if(nw < 0) | |
| 1920 | + error(Ebadarg); | |
| 1921 | + if(nw == 0) | |
| 1922 | + continue; | |
| 1923 | + m += nw*4; | |
| 1924 | + if(n < m) | |
| 1925 | + error(Eshortdraw); | |
| 1926 | + lp = malloc(nw*sizeof(Memimage*)); | |
| 1927 | + if(lp == 0) | |
| 1928 | + error(Enomem); | |
| 1929 | + if(waserror()){ | |
| 1930 | + free(lp); | |
| 1931 | + nexterror(); | |
| 1932 | + } | |
| 1933 | + for(j=0; j<nw; j++) | |
| 1934 | + lp[j] = drawimage(client, a+1+1+2+j*4); | |
| 1935 | + if(lp[0]->layer == 0) | |
| 1936 | + error("images are not windows"); | |
| 1937 | + for(j=1; j<nw; j++) | |
| 1938 | + if(lp[j]->layer->screen != lp[0]->layer->screen) | |
| 1939 | + error("images not on same screen"); | |
| 1940 | + if(a[1]) | |
| 1941 | + memltofrontn(lp, nw); | |
| 1942 | + else | |
| 1943 | + memltorearn(lp, nw); | |
| 1944 | + if(lp[0]->layer->screen->image->data == screenimage->data) | |
| 1945 | + for(j=0; j<nw; j++) | |
| 1946 | + addflush(lp[j]->layer->screenr); | |
| 1947 | + ll = drawlookup(client, BGLONG(a+1+1+2), 1); | |
| 1948 | + drawrefreshscreen(ll, client); | |
| 1949 | + poperror(); | |
| 1950 | + free(lp); | |
| 1951 | + continue; | |
| 1952 | + | |
| 1953 | + /* visible: 'v' */ | |
| 1954 | + case 'v': | |
| 1955 | + printmesg(fmt="", a, 0); | |
| 1956 | + m = 1; | |
| 1957 | + drawflush(); | |
| 1958 | + continue; | |
| 1959 | + | |
| 1960 | + /* write: 'y' id[4] R[4*4] data[x*1] */ | |
| 1961 | + /* write from compressed data: 'Y' id[4] R[4*4] data[x*1] */ | |
| 1962 | + case 'y': | |
| 1963 | + case 'Y': | |
| 1964 | + printmesg(fmt="LR", a, 0); | |
| 1965 | + // iprint("load %c\n", *a); | |
| 1966 | + m = 1+4+4*4; | |
| 1967 | + if(n < m) | |
| 1968 | + error(Eshortdraw); | |
| 1969 | + dstid = BGLONG(a+1); | |
| 1970 | + dst = drawimage(client, a+1); | |
| 1971 | + drawrectangle(&r, a+5); | |
| 1972 | + if(!rectinrect(r, dst->r)) | |
| 1973 | + error(Ewriteoutside); | |
| 1974 | + y = memload(dst, r, a+m, n-m, *a=='Y'); | |
| 1975 | + if(y < 0) | |
| 1976 | + error("bad writeimage call"); | |
| 1977 | + dstflush(dstid, dst, r); | |
| 1978 | + m += y; | |
| 1979 | + continue; | |
| 1980 | + } | |
| 1981 | + } | |
| 1982 | + poperror(); | |
| 1983 | +} | |
| 1984 | + | |
| 1985 | +Dev drawdevtab = { | |
| 1986 | + 'i', | |
| 1987 | + "draw", | |
| 1988 | + | |
| 1989 | + devreset, | |
| 1990 | + devinit, | |
| 1991 | + devshutdown, | |
| 1992 | + drawattach, | |
| 1993 | + drawwalk, | |
| 1994 | + drawstat, | |
| 1995 | + drawopen, | |
| 1996 | + devcreate, | |
| 1997 | + drawclose, | |
| 1998 | + drawread, | |
| 1999 | + devbread, | |
| 2000 | + drawwrite, | |
| 2001 | + devbwrite, | |
| 2002 | + devremove, | |
| 2003 | + devwstat, | |
| 2004 | +}; | |
| 2005 | + | |
| 2006 | +/* | |
| 2007 | + * On 8 bit displays, load the default color map | |
| 2008 | + */ | |
| 2009 | +void | |
| 2010 | +drawcmap(void) | |
| 2011 | +{ | |
| 2012 | + int r, g, b, cr, cg, cb, v; | |
| 2013 | + int num, den; | |
| 2014 | + int i, j; | |
| 2015 | + | |
| 2016 | + drawactive(1); /* to restore map from backup */ | |
| 2017 | + for(r=0,i=0; r!=4; r++) | |
| 2018 | + for(v=0; v!=4; v++,i+=16){ | |
| 2019 | + for(g=0,j=v-r; g!=4; g++) | |
| 2020 | + for(b=0;b!=4;b++,j++){ | |
| 2021 | + den = r; | |
| 2022 | + if(g > den) | |
| 2023 | + den = g; | |
| 2024 | + if(b > den) | |
| 2025 | + den = b; | |
| 2026 | + if(den == 0) /* divide check -- pick grey shades */ | |
| 2027 | + cr = cg = cb = v*17; | |
| 2028 | + else{ | |
| 2029 | + num = 17*(4*den+v); | |
| 2030 | + cr = r*num/den; | |
| 2031 | + cg = g*num/den; | |
| 2032 | + cb = b*num/den; | |
| 2033 | + } | |
| 2034 | + setcolor(i+(j&15), | |
| 2035 | + cr*0x01010101, cg*0x01010101, cb*0x01010101); | |
| 2036 | + } | |
| 2037 | + } | |
| 2038 | +} | |
| 2039 | + | |
| 2040 | +void | |
| 2041 | +drawblankscreen(int blank) | |
| 2042 | +{ | |
| 2043 | + int i, nc; | |
| 2044 | + ulong *p; | |
| 2045 | + | |
| 2046 | + if(blank == sdraw.blanked) | |
| 2047 | + return; | |
| 2048 | + if(!canqlock(&sdraw.lk)) | |
| 2049 | + return; | |
| 2050 | + if(!initscreenimage()){ | |
| 2051 | + qunlock(&sdraw.lk); | |
| 2052 | + return; | |
| 2053 | + } | |
| 2054 | + p = sdraw.savemap; | |
| 2055 | + nc = screenimage->depth > 8 ? 256 : 1<<screenimage->depth; | |
| 2056 | + | |
| 2057 | + /* | |
| 2058 | + * blankscreen uses the hardware to blank the screen | |
| 2059 | + * when possible. to help in cases when it is not possible, | |
| 2060 | + * we set the color map to be all black. | |
| 2061 | + */ | |
| 2062 | + if(blank == 0){ /* turn screen on */ | |
| 2063 | + for(i=0; i<nc; i++, p+=3) | |
| 2064 | + setcolor(i, p[0], p[1], p[2]); | |
| 2065 | + // blankscreen(0); | |
| 2066 | + }else{ /* turn screen off */ | |
| 2067 | + // blankscreen(1); | |
| 2068 | + for(i=0; i<nc; i++, p+=3){ | |
| 2069 | + getcolor(i, &p[0], &p[1], &p[2]); | |
| 2070 | + setcolor(i, 0, 0, 0); | |
| 2071 | + } | |
| 2072 | + } | |
| 2073 | + sdraw.blanked = blank; | |
| 2074 | + qunlock(&sdraw.lk); | |
| 2075 | +} | |
| 2076 | + | |
| 2077 | +/* | |
| 2078 | + * record activity on screen, changing blanking as appropriate | |
| 2079 | + */ | |
| 2080 | +void | |
| 2081 | +drawactive(int active) | |
| 2082 | +{ | |
| 2083 | +/* | |
| 2084 | + if(active){ | |
| 2085 | + drawblankscreen(0); | |
| 2086 | + sdraw.blanktime = MACHP(0)->ticks; | |
| 2087 | + }else{ | |
| 2088 | + if(blanktime && sdraw.blanktime && TK2SEC(MACHP(0)->ticks - sdraw.blanktime)/60 >= blanktime) | |
| 2089 | + drawblankscreen(1); | |
| 2090 | + } | |
| 2091 | +*/ | |
| 2092 | +} | |
| 2093 | + | |
| 2094 | +int | |
| 2095 | +drawidletime(void) | |
| 2096 | +{ | |
| 2097 | + return 0; | |
| 2098 | +/* return TK2SEC(MACHP(0)->ticks - sdraw.blanktime)/60; */ | |
| 2099 | +} | |
| 2100 | + | |
| @@ -0,0 +1,638 @@ | ||
| 1 | +#include <sys/types.h> | |
| 2 | +#include <sys/stat.h> | |
| 3 | +#include <dirent.h> | |
| 4 | +#include <fcntl.h> | |
| 5 | +#include <errno.h> | |
| 6 | +#include <stdio.h> /* for remove, rename */ | |
| 7 | +#include <limits.h> | |
| 8 | + | |
| 9 | +#ifndef NAME_MAX | |
| 10 | +# define NAME_MAX 256 | |
| 11 | +#endif | |
| 12 | +#include "u.h" | |
| 13 | +#include "lib.h" | |
| 14 | +#include "dat.h" | |
| 15 | +#include "fns.h" | |
| 16 | +#include "error.h" | |
| 17 | + | |
| 18 | + | |
| 19 | +typedef struct Ufsinfo Ufsinfo; | |
| 20 | + | |
| 21 | +enum | |
| 22 | +{ | |
| 23 | + NUID = 256, | |
| 24 | + NGID = 256, | |
| 25 | + MAXPATH = 1024, | |
| 26 | + MAXCOMP = 128 | |
| 27 | +}; | |
| 28 | + | |
| 29 | +struct Ufsinfo | |
| 30 | +{ | |
| 31 | + int mode; | |
| 32 | + int fd; | |
| 33 | + int uid; | |
| 34 | + int gid; | |
| 35 | + DIR* dir; | |
| 36 | + ulong offset; | |
| 37 | + QLock oq; | |
| 38 | + char nextname[NAME_MAX]; | |
| 39 | +}; | |
| 40 | + | |
| 41 | +char *base = "/"; | |
| 42 | + | |
| 43 | +static Qid fsqid(char*, struct stat *); | |
| 44 | +static void fspath(Chan*, char*, char*); | |
| 45 | +static ulong fsdirread(Chan*, uchar*, int, ulong); | |
| 46 | +static int fsomode(int); | |
| 47 | + | |
| 48 | +/* clumsy hack, but not worse than the Path stuff in the last one */ | |
| 49 | +static char* | |
| 50 | +uc2name(Chan *c) | |
| 51 | +{ | |
| 52 | + char *s; | |
| 53 | + | |
| 54 | + if(c->name == nil) | |
| 55 | + return "/"; | |
| 56 | + s = c2name(c); | |
| 57 | + if(s[0]=='#' && s[1]=='U') | |
| 58 | + return s+2; | |
| 59 | + return s; | |
| 60 | +} | |
| 61 | + | |
| 62 | +static char* | |
| 63 | +lastelem(Chan *c) | |
| 64 | +{ | |
| 65 | + char *s, *t; | |
| 66 | + | |
| 67 | + s = uc2name(c); | |
| 68 | + if((t = strrchr(s, '/')) == nil) | |
| 69 | + return s; | |
| 70 | + if(t[1] == 0) | |
| 71 | + return t; | |
| 72 | + return t+1; | |
| 73 | +} | |
| 74 | + | |
| 75 | +static Chan* | |
| 76 | +fsattach(char *spec) | |
| 77 | +{ | |
| 78 | + Chan *c; | |
| 79 | + struct stat stbuf; | |
| 80 | + static int devno; | |
| 81 | + Ufsinfo *uif; | |
| 82 | + | |
| 83 | + if(stat(base, &stbuf) < 0) | |
| 84 | + error(strerror(errno)); | |
| 85 | + | |
| 86 | + c = devattach('U', spec); | |
| 87 | + | |
| 88 | + uif = mallocz(sizeof(Ufsinfo), 1); | |
| 89 | + uif->mode = stbuf.st_mode; | |
| 90 | + uif->uid = stbuf.st_uid; | |
| 91 | + uif->gid = stbuf.st_gid; | |
| 92 | + | |
| 93 | + c->aux = uif; | |
| 94 | + c->dev = devno++; | |
| 95 | + c->qid.type = QTDIR; | |
| 96 | +/*print("fsattach %s\n", c2name(c));*/ | |
| 97 | + | |
| 98 | + return c; | |
| 99 | +} | |
| 100 | + | |
| 101 | +static Chan* | |
| 102 | +fsclone(Chan *c, Chan *nc) | |
| 103 | +{ | |
| 104 | + Ufsinfo *uif; | |
| 105 | + | |
| 106 | + uif = mallocz(sizeof(Ufsinfo), 1); | |
| 107 | + *uif = *(Ufsinfo*)c->aux; | |
| 108 | + nc->aux = uif; | |
| 109 | + | |
| 110 | + return nc; | |
| 111 | +} | |
| 112 | + | |
| 113 | +static int | |
| 114 | +fswalk1(Chan *c, char *name) | |
| 115 | +{ | |
| 116 | + struct stat stbuf; | |
| 117 | + char path[MAXPATH]; | |
| 118 | + Ufsinfo *uif; | |
| 119 | + | |
| 120 | + fspath(c, name, path); | |
| 121 | + | |
| 122 | + /*print("** fs walk '%s' -> %s\n", path, name); */ | |
| 123 | + | |
| 124 | + if(stat(path, &stbuf) < 0) | |
| 125 | + return 0; | |
| 126 | + | |
| 127 | + uif = c->aux; | |
| 128 | + | |
| 129 | + uif->mode = stbuf.st_mode; | |
| 130 | + uif->uid = stbuf.st_uid; | |
| 131 | + uif->gid = stbuf.st_gid; | |
| 132 | + | |
| 133 | + c->qid = fsqid(path, &stbuf); | |
| 134 | + | |
| 135 | + return 1; | |
| 136 | +} | |
| 137 | + | |
| 138 | +extern Cname* addelem(Cname*, char*); | |
| 139 | + | |
| 140 | +static Walkqid* | |
| 141 | +fswalk(Chan *c, Chan *nc, char **name, int nname) | |
| 142 | +{ | |
| 143 | + int i; | |
| 144 | + Cname *cname; | |
| 145 | + Walkqid *wq; | |
| 146 | + | |
| 147 | + if(nc != nil) | |
| 148 | + panic("fswalk: nc != nil"); | |
| 149 | + wq = smalloc(sizeof(Walkqid)+(nname-1)*sizeof(Qid)); | |
| 150 | + nc = devclone(c); | |
| 151 | + cname = c->name; | |
| 152 | + incref(&cname->ref); | |
| 153 | + | |
| 154 | + fsclone(c, nc); | |
| 155 | + wq->clone = nc; | |
| 156 | + for(i=0; i<nname; i++){ | |
| 157 | + nc->name = cname; | |
| 158 | + if(fswalk1(nc, name[i]) == 0) | |
| 159 | + break; | |
| 160 | + cname = addelem(cname, name[i]); | |
| 161 | + wq->qid[i] = nc->qid; | |
| 162 | + } | |
| 163 | + nc->name = nil; | |
| 164 | + cnameclose(cname); | |
| 165 | + if(i != nname){ | |
| 166 | + cclose(nc); | |
| 167 | + wq->clone = nil; | |
| 168 | + } | |
| 169 | + wq->nqid = i; | |
| 170 | + return wq; | |
| 171 | +} | |
| 172 | + | |
| 173 | +static int | |
| 174 | +fsstat(Chan *c, uchar *buf, int n) | |
| 175 | +{ | |
| 176 | + Dir d; | |
| 177 | + struct stat stbuf; | |
| 178 | + char path[MAXPATH]; | |
| 179 | + | |
| 180 | + if(n < BIT16SZ) | |
| 181 | + error(Eshortstat); | |
| 182 | + | |
| 183 | + fspath(c, 0, path); | |
| 184 | + if(stat(path, &stbuf) < 0) | |
| 185 | + error(strerror(errno)); | |
| 186 | + | |
| 187 | + d.name = lastelem(c); | |
| 188 | + d.uid = "unknown"; | |
| 189 | + d.gid = "unknown"; | |
| 190 | + d.muid = "unknown"; | |
| 191 | + d.qid = c->qid; | |
| 192 | + d.mode = (c->qid.type<<24)|(stbuf.st_mode&0777); | |
| 193 | + d.atime = stbuf.st_atime; | |
| 194 | + d.mtime = stbuf.st_mtime; | |
| 195 | + d.length = stbuf.st_size; | |
| 196 | + d.type = 'U'; | |
| 197 | + d.dev = c->dev; | |
| 198 | + return convD2M(&d, buf, n); | |
| 199 | +} | |
| 200 | + | |
| 201 | +static Chan* | |
| 202 | +fsopen(Chan *c, int mode) | |
| 203 | +{ | |
| 204 | + char path[MAXPATH]; | |
| 205 | + int m, isdir; | |
| 206 | + Ufsinfo *uif; | |
| 207 | + | |
| 208 | +/*print("fsopen %s\n", c2name(c));*/ | |
| 209 | + m = mode & (OTRUNC|3); | |
| 210 | + switch(m) { | |
| 211 | + case 0: | |
| 212 | + break; | |
| 213 | + case 1: | |
| 214 | + case 1|16: | |
| 215 | + break; | |
| 216 | + case 2: | |
| 217 | + case 0|16: | |
| 218 | + case 2|16: | |
| 219 | + break; | |
| 220 | + case 3: | |
| 221 | + break; | |
| 222 | + default: | |
| 223 | + error(Ebadarg); | |
| 224 | + } | |
| 225 | + | |
| 226 | + isdir = c->qid.type & QTDIR; | |
| 227 | + | |
| 228 | + if(isdir && mode != OREAD) | |
| 229 | + error(Eperm); | |
| 230 | + | |
| 231 | + m = fsomode(m & 3); | |
| 232 | + c->mode = openmode(mode); | |
| 233 | + | |
| 234 | + uif = c->aux; | |
| 235 | + | |
| 236 | + fspath(c, 0, path); | |
| 237 | + if(isdir) { | |
| 238 | + uif->dir = opendir(path); | |
| 239 | + if(uif->dir == 0) | |
| 240 | + error(strerror(errno)); | |
| 241 | + } | |
| 242 | + else { | |
| 243 | + if(mode & OTRUNC) | |
| 244 | + m |= O_TRUNC; | |
| 245 | + uif->fd = open(path, m, 0666); | |
| 246 | + | |
| 247 | + if(uif->fd < 0) | |
| 248 | + error(strerror(errno)); | |
| 249 | + } | |
| 250 | + uif->offset = 0; | |
| 251 | + | |
| 252 | + c->offset = 0; | |
| 253 | + c->flag |= COPEN; | |
| 254 | + return c; | |
| 255 | +} | |
| 256 | + | |
| 257 | +static void | |
| 258 | +fscreate(Chan *c, char *name, int mode, ulong perm) | |
| 259 | +{ | |
| 260 | + int fd, m; | |
| 261 | + char path[MAXPATH]; | |
| 262 | + struct stat stbuf; | |
| 263 | + Ufsinfo *uif; | |
| 264 | + | |
| 265 | + m = fsomode(mode&3); | |
| 266 | + | |
| 267 | + fspath(c, name, path); | |
| 268 | + | |
| 269 | + uif = c->aux; | |
| 270 | + | |
| 271 | + if(perm & DMDIR) { | |
| 272 | + if(m) | |
| 273 | + error(Eperm); | |
| 274 | + | |
| 275 | + if(mkdir(path, perm & 0777) < 0) | |
| 276 | + error(strerror(errno)); | |
| 277 | + | |
| 278 | + fd = open(path, 0); | |
| 279 | + if(fd >= 0) { | |
| 280 | + chmod(path, perm & 0777); | |
| 281 | + chown(path, uif->uid, uif->uid); | |
| 282 | + } | |
| 283 | + close(fd); | |
| 284 | + | |
| 285 | + uif->dir = opendir(path); | |
| 286 | + if(uif->dir == 0) | |
| 287 | + error(strerror(errno)); | |
| 288 | + } | |
| 289 | + else { | |
| 290 | + fd = open(path, O_WRONLY|O_CREAT|O_TRUNC, 0666); | |
| 291 | + if(fd >= 0) { | |
| 292 | + if(m != 1) { | |
| 293 | + close(fd); | |
| 294 | + fd = open(path, m); | |
| 295 | + } | |
| 296 | + chmod(path, perm & 0777); | |
| 297 | + chown(path, uif->uid, uif->gid); | |
| 298 | + } | |
| 299 | + if(fd < 0) | |
| 300 | + error(strerror(errno)); | |
| 301 | + uif->fd = fd; | |
| 302 | + } | |
| 303 | + | |
| 304 | + if(stat(path, &stbuf) < 0) | |
| 305 | + error(strerror(errno)); | |
| 306 | + c->qid = fsqid(path, &stbuf); | |
| 307 | + c->offset = 0; | |
| 308 | + c->flag |= COPEN; | |
| 309 | + c->mode = openmode(mode); | |
| 310 | +} | |
| 311 | + | |
| 312 | +static void | |
| 313 | +fsclose(Chan *c) | |
| 314 | +{ | |
| 315 | + Ufsinfo *uif; | |
| 316 | + | |
| 317 | + uif = c->aux; | |
| 318 | + | |
| 319 | + if(c->flag & COPEN) { | |
| 320 | + if(c->qid.type & QTDIR) | |
| 321 | + closedir(uif->dir); | |
| 322 | + else | |
| 323 | + close(uif->fd); | |
| 324 | + } | |
| 325 | + | |
| 326 | + free(uif); | |
| 327 | +} | |
| 328 | + | |
| 329 | +static long | |
| 330 | +fsread(Chan *c, void *va, long n, vlong offset) | |
| 331 | +{ | |
| 332 | + int fd, r; | |
| 333 | + Ufsinfo *uif; | |
| 334 | + | |
| 335 | +/*print("fsread %s\n", c2name(c));*/ | |
| 336 | + if(c->qid.type & QTDIR) | |
| 337 | + return fsdirread(c, va, n, offset); | |
| 338 | + | |
| 339 | + uif = c->aux; | |
| 340 | + qlock(&uif->oq); | |
| 341 | + if(waserror()) { | |
| 342 | + qunlock(&uif->oq); | |
| 343 | + nexterror(); | |
| 344 | + } | |
| 345 | + fd = uif->fd; | |
| 346 | + if(uif->offset != offset) { | |
| 347 | + r = lseek(fd, offset, 0); | |
| 348 | + if(r < 0) | |
| 349 | + error(strerror(errno)); | |
| 350 | + uif->offset = offset; | |
| 351 | + } | |
| 352 | + | |
| 353 | + n = read(fd, va, n); | |
| 354 | + if(n < 0) | |
| 355 | + error(strerror(errno)); | |
| 356 | + | |
| 357 | + uif->offset += n; | |
| 358 | + qunlock(&uif->oq); | |
| 359 | + poperror(); | |
| 360 | + | |
| 361 | + return n; | |
| 362 | +} | |
| 363 | + | |
| 364 | +static long | |
| 365 | +fswrite(Chan *c, void *va, long n, vlong offset) | |
| 366 | +{ | |
| 367 | + int fd, r; | |
| 368 | + Ufsinfo *uif; | |
| 369 | + | |
| 370 | + uif = c->aux; | |
| 371 | + | |
| 372 | + qlock(&uif->oq); | |
| 373 | + if(waserror()) { | |
| 374 | + qunlock(&uif->oq); | |
| 375 | + nexterror(); | |
| 376 | + } | |
| 377 | + fd = uif->fd; | |
| 378 | + if(uif->offset != offset) { | |
| 379 | + r = lseek(fd, offset, 0); | |
| 380 | + if(r < 0) | |
| 381 | + error(strerror(errno)); | |
| 382 | + uif->offset = offset; | |
| 383 | + } | |
| 384 | + | |
| 385 | + n = write(fd, va, n); | |
| 386 | + if(n < 0) | |
| 387 | + error(strerror(errno)); | |
| 388 | + | |
| 389 | + uif->offset += n; | |
| 390 | + qunlock(&uif->oq); | |
| 391 | + poperror(); | |
| 392 | + | |
| 393 | + return n; | |
| 394 | +} | |
| 395 | + | |
| 396 | +static void | |
| 397 | +fsremove(Chan *c) | |
| 398 | +{ | |
| 399 | + int n; | |
| 400 | + char path[MAXPATH]; | |
| 401 | + | |
| 402 | + fspath(c, 0, path); | |
| 403 | + if(c->qid.type & QTDIR) | |
| 404 | + n = rmdir(path); | |
| 405 | + else | |
| 406 | + n = remove(path); | |
| 407 | + if(n < 0) | |
| 408 | + error(strerror(errno)); | |
| 409 | +} | |
| 410 | + | |
| 411 | +int | |
| 412 | +fswstat(Chan *c, uchar *buf, int n) | |
| 413 | +{ | |
| 414 | + Dir d; | |
| 415 | + struct stat stbuf; | |
| 416 | + char old[MAXPATH], new[MAXPATH], dir[MAXPATH]; | |
| 417 | + char strs[MAXPATH*3], *p; | |
| 418 | + Ufsinfo *uif; | |
| 419 | + | |
| 420 | + if(convM2D(buf, n, &d, strs) != n) | |
| 421 | + error(Ebadstat); | |
| 422 | + | |
| 423 | + fspath(c, 0, old); | |
| 424 | + if(stat(old, &stbuf) < 0) | |
| 425 | + error(strerror(errno)); | |
| 426 | + | |
| 427 | + uif = c->aux; | |
| 428 | + | |
| 429 | + if(d.name[0] && strcmp(d.name, lastelem(c)) != 0) { | |
| 430 | + fspath(c, 0, old); | |
| 431 | + strcpy(new, old); | |
| 432 | + p = strrchr(new, '/'); | |
| 433 | + strcpy(p+1, d.name); | |
| 434 | + if(rename(old, new) < 0) | |
| 435 | + error(strerror(errno)); | |
| 436 | + } | |
| 437 | + | |
| 438 | + fspath(c, 0, old); | |
| 439 | + if(~d.mode != 0 && (int)(d.mode&0777) != (int)(stbuf.st_mode&0777)) { | |
| 440 | + if(chmod(old, d.mode&0777) < 0) | |
| 441 | + error(strerror(errno)); | |
| 442 | + uif->mode &= ~0777; | |
| 443 | + uif->mode |= d.mode&0777; | |
| 444 | + } | |
| 445 | +/* | |
| 446 | + p = name2pass(gid, d.gid); | |
| 447 | + if(p == 0) | |
| 448 | + error(Eunknown); | |
| 449 | + | |
| 450 | + if(p->id != stbuf.st_gid) { | |
| 451 | + if(chown(old, stbuf.st_uid, p->id) < 0) | |
| 452 | + error(strerror(errno)); | |
| 453 | + | |
| 454 | + uif->gid = p->id; | |
| 455 | + } | |
| 456 | +*/ | |
| 457 | + return n; | |
| 458 | +} | |
| 459 | + | |
| 460 | +static Qid | |
| 461 | +fsqid(char *p, struct stat *st) | |
| 462 | +{ | |
| 463 | + Qid q; | |
| 464 | + int dev; | |
| 465 | + ulong h; | |
| 466 | + static int nqdev; | |
| 467 | + static uchar *qdev; | |
| 468 | + | |
| 469 | + if(qdev == 0) | |
| 470 | + qdev = mallocz(65536U, 1); | |
| 471 | + | |
| 472 | + q.type = 0; | |
| 473 | + if((st->st_mode&S_IFMT) == S_IFDIR) | |
| 474 | + q.type = QTDIR; | |
| 475 | + | |
| 476 | + dev = st->st_dev & 0xFFFFUL; | |
| 477 | + if(qdev[dev] == 0) | |
| 478 | + qdev[dev] = ++nqdev; | |
| 479 | + | |
| 480 | + h = 0; | |
| 481 | + while(*p != '\0') | |
| 482 | + h += *p++ * 13; | |
| 483 | + | |
| 484 | + q.path = (vlong)qdev[dev]<<32; | |
| 485 | + q.path |= h; | |
| 486 | + q.vers = st->st_mtime; | |
| 487 | + | |
| 488 | + return q; | |
| 489 | +} | |
| 490 | + | |
| 491 | +static void | |
| 492 | +fspath(Chan *c, char *ext, char *path) | |
| 493 | +{ | |
| 494 | + int i, n; | |
| 495 | + char *comp[MAXCOMP]; | |
| 496 | + | |
| 497 | + strcpy(path, base); | |
| 498 | + strcat(path, "/"); | |
| 499 | + strcat(path, uc2name(c)); | |
| 500 | + if(ext){ | |
| 501 | + strcat(path, "/"); | |
| 502 | + strcat(path, ext); | |
| 503 | + } | |
| 504 | + cleanname(path); | |
| 505 | +} | |
| 506 | + | |
| 507 | +static int | |
| 508 | +isdots(char *name) | |
| 509 | +{ | |
| 510 | + if(name[0] != '.') | |
| 511 | + return 0; | |
| 512 | + if(name[1] == '\0') | |
| 513 | + return 1; | |
| 514 | + if(name[1] != '.') | |
| 515 | + return 0; | |
| 516 | + if(name[2] == '\0') | |
| 517 | + return 1; | |
| 518 | + return 0; | |
| 519 | +} | |
| 520 | + | |
| 521 | +static int | |
| 522 | +p9readdir(char *name, Ufsinfo *uif) | |
| 523 | +{ | |
| 524 | + struct dirent *de; | |
| 525 | + | |
| 526 | + if(uif->nextname[0]){ | |
| 527 | + strcpy(name, uif->nextname); | |
| 528 | + uif->nextname[0] = 0; | |
| 529 | + return 1; | |
| 530 | + } | |
| 531 | + | |
| 532 | + de = readdir(uif->dir); | |
| 533 | + if(de == NULL) | |
| 534 | + return 0; | |
| 535 | + | |
| 536 | + strcpy(name, de->d_name); | |
| 537 | + return 1; | |
| 538 | +} | |
| 539 | + | |
| 540 | +static ulong | |
| 541 | +fsdirread(Chan *c, uchar *va, int count, ulong offset) | |
| 542 | +{ | |
| 543 | + int i; | |
| 544 | + Dir d; | |
| 545 | + long n; | |
| 546 | + char de[NAME_MAX]; | |
| 547 | + struct stat stbuf; | |
| 548 | + char path[MAXPATH], dirpath[MAXPATH]; | |
| 549 | + Ufsinfo *uif; | |
| 550 | + | |
| 551 | +/*print("fsdirread %s\n", c2name(c));*/ | |
| 552 | + i = 0; | |
| 553 | + uif = c->aux; | |
| 554 | + | |
| 555 | + errno = 0; | |
| 556 | + if(uif->offset != offset) { | |
| 557 | + if(offset != 0) | |
| 558 | + error("bad offset in fsdirread"); | |
| 559 | + uif->offset = offset; /* sync offset */ | |
| 560 | + uif->nextname[0] = 0; | |
| 561 | + rewinddir(uif->dir); | |
| 562 | + } | |
| 563 | + | |
| 564 | + fspath(c, 0, dirpath); | |
| 565 | + | |
| 566 | + while(i+BIT16SZ < count) { | |
| 567 | + if(!p9readdir(de, uif)) | |
| 568 | + break; | |
| 569 | + | |
| 570 | + if(de[0]==0 || isdots(de)) | |
| 571 | + continue; | |
| 572 | + | |
| 573 | + d.name = de; | |
| 574 | + sprint(path, "%s/%s", dirpath, de); | |
| 575 | + memset(&stbuf, 0, sizeof stbuf); | |
| 576 | + | |
| 577 | + if(stat(path, &stbuf) < 0) { | |
| 578 | + print("dir: bad path %s\n", path); | |
| 579 | + /* but continue... probably a bad symlink */ | |
| 580 | + } | |
| 581 | + | |
| 582 | + d.uid = "unknown"; | |
| 583 | + d.gid = "unknown"; | |
| 584 | + d.qid = fsqid(path, &stbuf); | |
| 585 | + d.mode = (d.qid.type<<24)|(stbuf.st_mode&0777); | |
| 586 | + d.atime = stbuf.st_atime; | |
| 587 | + d.mtime = stbuf.st_mtime; | |
| 588 | + d.length = stbuf.st_size; | |
| 589 | + d.type = 'U'; | |
| 590 | + d.dev = c->dev; | |
| 591 | + n = convD2M(&d, (char*)va+i, count-i); | |
| 592 | + if(n == BIT16SZ){ | |
| 593 | + strcpy(uif->nextname, de); | |
| 594 | + break; | |
| 595 | + } | |
| 596 | + i += n; | |
| 597 | + } | |
| 598 | +/*print("got %d\n", i);*/ | |
| 599 | + uif->offset += i; | |
| 600 | + return i; | |
| 601 | +} | |
| 602 | + | |
| 603 | +static int | |
| 604 | +fsomode(int m) | |
| 605 | +{ | |
| 606 | + switch(m) { | |
| 607 | + case 0: /* OREAD */ | |
| 608 | + case 3: /* OEXEC */ | |
| 609 | + return 0; | |
| 610 | + case 1: /* OWRITE */ | |
| 611 | + return 1; | |
| 612 | + case 2: /* ORDWR */ | |
| 613 | + return 2; | |
| 614 | + } | |
| 615 | + error(Ebadarg); | |
| 616 | + return 0; | |
| 617 | +} | |
| 618 | + | |
| 619 | +Dev fsdevtab = { | |
| 620 | + 'U', | |
| 621 | + "fs", | |
| 622 | + | |
| 623 | + devreset, | |
| 624 | + devinit, | |
| 625 | + devshutdown, | |
| 626 | + fsattach, | |
| 627 | + fswalk, | |
| 628 | + fsstat, | |
| 629 | + fsopen, | |
| 630 | + fscreate, | |
| 631 | + fsclose, | |
| 632 | + fsread, | |
| 633 | + devbread, | |
| 634 | + fswrite, | |
| 635 | + devbwrite, | |
| 636 | + fsremove, | |
| 637 | + fswstat, | |
| 638 | +}; | |
| @@ -0,0 +1,209 @@ | ||
| 1 | +#include <sys/types.h> | |
| 2 | +#include <sys/socket.h> | |
| 3 | +#include <netinet/in.h> | |
| 4 | +#include <netinet/tcp.h> | |
| 5 | +#include <netdb.h> | |
| 6 | + | |
| 7 | +#include "u.h" | |
| 8 | +#include "lib.h" | |
| 9 | +#include "dat.h" | |
| 10 | +#include "fns.h" | |
| 11 | +#include "error.h" | |
| 12 | + | |
| 13 | +#include "devip.h" | |
| 14 | + | |
| 15 | +#undef listen | |
| 16 | +#undef accept | |
| 17 | +#undef bind | |
| 18 | + | |
| 19 | +void | |
| 20 | +osipinit(void) | |
| 21 | +{ | |
| 22 | + char buf[1024]; | |
| 23 | + gethostname(buf, sizeof(buf)); | |
| 24 | + kstrdup(&sysname, buf); | |
| 25 | + | |
| 26 | +} | |
| 27 | + | |
| 28 | +int | |
| 29 | +so_socket(int type) | |
| 30 | +{ | |
| 31 | + int fd, one; | |
| 32 | + | |
| 33 | + switch(type) { | |
| 34 | + default: | |
| 35 | + error("bad protocol type"); | |
| 36 | + case S_TCP: | |
| 37 | + type = SOCK_STREAM; | |
| 38 | + break; | |
| 39 | + case S_UDP: | |
| 40 | + type = SOCK_DGRAM; | |
| 41 | + break; | |
| 42 | + } | |
| 43 | + | |
| 44 | + fd = socket(AF_INET, type, 0); | |
| 45 | + if(fd < 0) | |
| 46 | + oserror(); | |
| 47 | + | |
| 48 | + one = 1; | |
| 49 | + if(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&one, sizeof(one)) > 0){ | |
| 50 | + oserrstr(); | |
| 51 | + print("setsockopt: %r"); | |
| 52 | + } | |
| 53 | + | |
| 54 | + return fd; | |
| 55 | +} | |
| 56 | + | |
| 57 | + | |
| 58 | +void | |
| 59 | +so_connect(int fd, unsigned long raddr, unsigned short rport) | |
| 60 | +{ | |
| 61 | + struct sockaddr_in sin; | |
| 62 | + | |
| 63 | + memset(&sin, 0, sizeof(sin)); | |
| 64 | + sin.sin_family = AF_INET; | |
| 65 | + hnputs(&sin.sin_port, rport); | |
| 66 | + hnputl(&sin.sin_addr.s_addr, raddr); | |
| 67 | + | |
| 68 | + if(connect(fd, (struct sockaddr*)&sin, sizeof(sin)) < 0) | |
| 69 | + oserror(); | |
| 70 | +} | |
| 71 | + | |
| 72 | +void | |
| 73 | +so_getsockname(int fd, unsigned long *laddr, unsigned short *lport) | |
| 74 | +{ | |
| 75 | + int len; | |
| 76 | + struct sockaddr_in sin; | |
| 77 | + | |
| 78 | + len = sizeof(sin); | |
| 79 | + if(getsockname(fd, (struct sockaddr*)&sin, &len) < 0) | |
| 80 | + oserror(); | |
| 81 | + | |
| 82 | + if(sin.sin_family != AF_INET || len != sizeof(sin)) | |
| 83 | + error("not AF_INET"); | |
| 84 | + | |
| 85 | + *laddr = nhgetl(&sin.sin_addr.s_addr); | |
| 86 | + *lport = nhgets(&sin.sin_port); | |
| 87 | +} | |
| 88 | + | |
| 89 | +void | |
| 90 | +so_listen(int fd) | |
| 91 | +{ | |
| 92 | + if(listen(fd, 5) < 0) | |
| 93 | + oserror(); | |
| 94 | +} | |
| 95 | + | |
| 96 | +int | |
| 97 | +so_accept(int fd, unsigned long *raddr, unsigned short *rport) | |
| 98 | +{ | |
| 99 | + int nfd, len; | |
| 100 | + struct sockaddr_in sin; | |
| 101 | + | |
| 102 | + len = sizeof(sin); | |
| 103 | + nfd = accept(fd, (struct sockaddr*)&sin, &len); | |
| 104 | + if(nfd < 0) | |
| 105 | + oserror(); | |
| 106 | + | |
| 107 | + if(sin.sin_family != AF_INET || len != sizeof(sin)) | |
| 108 | + error("not AF_INET"); | |
| 109 | + | |
| 110 | + *raddr = nhgetl(&sin.sin_addr.s_addr); | |
| 111 | + *rport = nhgets(&sin.sin_port); | |
| 112 | + return nfd; | |
| 113 | +} | |
| 114 | + | |
| 115 | +void | |
| 116 | +so_bind(int fd, int su, unsigned short port) | |
| 117 | +{ | |
| 118 | + int i, one; | |
| 119 | + struct sockaddr_in sin; | |
| 120 | + | |
| 121 | + one = 1; | |
| 122 | + if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&one, sizeof(one)) < 0){ | |
| 123 | + oserrstr(); | |
| 124 | + print("setsockopt: %r"); | |
| 125 | + } | |
| 126 | + | |
| 127 | + if(su) { | |
| 128 | + for(i = 600; i < 1024; i++) { | |
| 129 | + memset(&sin, 0, sizeof(sin)); | |
| 130 | + sin.sin_family = AF_INET; | |
| 131 | + sin.sin_port = i; | |
| 132 | + | |
| 133 | + if(bind(fd, (struct sockaddr*)&sin, sizeof(sin)) >= 0) | |
| 134 | + return; | |
| 135 | + } | |
| 136 | + oserror(); | |
| 137 | + } | |
| 138 | + | |
| 139 | + memset(&sin, 0, sizeof(sin)); | |
| 140 | + sin.sin_family = AF_INET; | |
| 141 | + hnputs(&sin.sin_port, port); | |
| 142 | + | |
| 143 | + if(bind(fd, (struct sockaddr*)&sin, sizeof(sin)) < 0) | |
| 144 | + oserror(); | |
| 145 | +} | |
| 146 | + | |
| 147 | +int | |
| 148 | +so_gethostbyname(char *host, char**hostv, int n) | |
| 149 | +{ | |
| 150 | + int i; | |
| 151 | + char buf[32]; | |
| 152 | + unsigned char *p; | |
| 153 | + struct hostent *hp; | |
| 154 | + | |
| 155 | + hp = gethostbyname(host); | |
| 156 | + if(hp == 0) | |
| 157 | + return 0; | |
| 158 | + | |
| 159 | + for(i = 0; hp->h_addr_list[i] && i < n; i++) { | |
| 160 | + p = (unsigned char*)hp->h_addr_list[i]; | |
| 161 | + sprint(buf, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]); | |
| 162 | + hostv[i] = strdup(buf); | |
| 163 | + if(hostv[i] == 0) | |
| 164 | + break; | |
| 165 | + } | |
| 166 | + return i; | |
| 167 | +} | |
| 168 | + | |
| 169 | +char* | |
| 170 | +hostlookup(char *host) | |
| 171 | +{ | |
| 172 | + char buf[100]; | |
| 173 | + uchar *p; | |
| 174 | + struct hostent *he; | |
| 175 | + | |
| 176 | + he = gethostbyname(host); | |
| 177 | + if(he != 0 && he->h_addr_list[0]) { | |
| 178 | + p = (uchar*)he->h_addr_list[0]; | |
| 179 | + sprint(buf, "%ud.%ud.%ud.%ud", p[0], p[1], p[2], p[3]); | |
| 180 | + } else | |
| 181 | + strcpy(buf, host); | |
| 182 | + | |
| 183 | + return strdup(buf); | |
| 184 | +} | |
| 185 | + | |
| 186 | +int | |
| 187 | +so_getservbyname(char *service, char *net, char *port) | |
| 188 | +{ | |
| 189 | + struct servent *s; | |
| 190 | + | |
| 191 | + s = getservbyname(service, net); | |
| 192 | + if(s == 0) | |
| 193 | + return -1; | |
| 194 | + | |
| 195 | + sprint(port, "%d", nhgets(&s->s_port)); | |
| 196 | + return 0; | |
| 197 | +} | |
| 198 | + | |
| 199 | +int | |
| 200 | +so_send(int fd, void *d, int n, int f) | |
| 201 | +{ | |
| 202 | + send(fd, d, n, f); | |
| 203 | +} | |
| 204 | + | |
| 205 | +int | |
| 206 | +so_recv(int fd, void *d, int n, int f) | |
| 207 | +{ | |
| 208 | + return recv(fd, d, n, f); | |
| 209 | +} | |
| @@ -0,0 +1,208 @@ | ||
| 1 | +#include <windows.h> | |
| 2 | +#include "winduhz.h" | |
| 3 | +#include "u.h" | |
| 4 | +#include "lib.h" | |
| 5 | +#include "dat.h" | |
| 6 | +#include "fns.h" | |
| 7 | +#include "error.h" | |
| 8 | + | |
| 9 | +#include "devip.h" | |
| 10 | + | |
| 11 | +#pragma comment(lib, "wsock32.lib") | |
| 12 | + | |
| 13 | +#undef listen | |
| 14 | +#undef accept | |
| 15 | +#undef bind | |
| 16 | + | |
| 17 | +void | |
| 18 | +osipinit(void) | |
| 19 | +{ | |
| 20 | + WSADATA wasdat; | |
| 21 | + char buf[1024]; | |
| 22 | + | |
| 23 | + if(WSAStartup(MAKEWORD(1, 1), &wasdat) != 0) | |
| 24 | + panic("no winsock.dll"); | |
| 25 | + | |
| 26 | + gethostname(buf, sizeof(buf)); | |
| 27 | + kstrdup(&sysname, buf); | |
| 28 | +} | |
| 29 | + | |
| 30 | +int | |
| 31 | +so_socket(int type) | |
| 32 | +{ | |
| 33 | + int fd, one; | |
| 34 | + | |
| 35 | + switch(type) { | |
| 36 | + default: | |
| 37 | + error("bad protocol type"); | |
| 38 | + case S_TCP: | |
| 39 | + type = SOCK_STREAM; | |
| 40 | + break; | |
| 41 | + case S_UDP: | |
| 42 | + type = SOCK_DGRAM; | |
| 43 | + break; | |
| 44 | + } | |
| 45 | + | |
| 46 | + fd = socket(AF_INET, type, 0); | |
| 47 | + if(fd < 0) | |
| 48 | + error(sys_errlist[errno]); | |
| 49 | + | |
| 50 | + one = 1; | |
| 51 | + if(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&one, sizeof(one)) > 0) | |
| 52 | + print("setsockopt: %s", sys_errlist[errno]); | |
| 53 | + | |
| 54 | + | |
| 55 | + return fd; | |
| 56 | +} | |
| 57 | + | |
| 58 | + | |
| 59 | +void | |
| 60 | +so_connect(int fd, unsigned long raddr, unsigned short rport) | |
| 61 | +{ | |
| 62 | + struct sockaddr_in sin; | |
| 63 | + | |
| 64 | + memset(&sin, 0, sizeof(sin)); | |
| 65 | + sin.sin_family = AF_INET; | |
| 66 | + hnputs(&sin.sin_port, rport); | |
| 67 | + hnputl(&sin.sin_addr.s_addr, raddr); | |
| 68 | + | |
| 69 | + if(connect(fd, (struct sockaddr*)&sin, sizeof(sin)) < 0) | |
| 70 | + error(sys_errlist[errno]); | |
| 71 | +} | |
| 72 | + | |
| 73 | +void | |
| 74 | +so_getsockname(int fd, unsigned long *laddr, unsigned short *lport) | |
| 75 | +{ | |
| 76 | + int len; | |
| 77 | + struct sockaddr_in sin; | |
| 78 | + | |
| 79 | + len = sizeof(sin); | |
| 80 | + if(getsockname(fd, (struct sockaddr*)&sin, &len) < 0) | |
| 81 | + error(sys_errlist[errno]); | |
| 82 | + | |
| 83 | + if(sin.sin_family != AF_INET || len != sizeof(sin)) | |
| 84 | + error("not AF_INET"); | |
| 85 | + | |
| 86 | + *laddr = nhgetl(&sin.sin_addr.s_addr); | |
| 87 | + *lport = nhgets(&sin.sin_port); | |
| 88 | +} | |
| 89 | + | |
| 90 | +void | |
| 91 | +so_listen(int fd) | |
| 92 | +{ | |
| 93 | + if(listen(fd, 5) < 0) | |
| 94 | + error(sys_errlist[errno]); | |
| 95 | +} | |
| 96 | + | |
| 97 | +int | |
| 98 | +so_accept(int fd, unsigned long *raddr, unsigned short *rport) | |
| 99 | +{ | |
| 100 | + int nfd, len; | |
| 101 | + struct sockaddr_in sin; | |
| 102 | + | |
| 103 | + len = sizeof(sin); | |
| 104 | + nfd = accept(fd, (struct sockaddr*)&sin, &len); | |
| 105 | + if(nfd < 0) | |
| 106 | + error(sys_errlist[errno]); | |
| 107 | + | |
| 108 | + if(sin.sin_family != AF_INET || len != sizeof(sin)) | |
| 109 | + error("not AF_INET"); | |
| 110 | + | |
| 111 | + *raddr = nhgetl(&sin.sin_addr.s_addr); | |
| 112 | + *rport = nhgets(&sin.sin_port); | |
| 113 | + return nfd; | |
| 114 | +} | |
| 115 | + | |
| 116 | +void | |
| 117 | +so_bind(int fd, int su, unsigned short port) | |
| 118 | +{ | |
| 119 | + int i, one; | |
| 120 | + struct sockaddr_in sin; | |
| 121 | + | |
| 122 | + one = 1; | |
| 123 | + if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&one, sizeof(one)) < 0) | |
| 124 | + print("setsockopt: %s", sys_errlist[errno]); | |
| 125 | + | |
| 126 | + if(su) { | |
| 127 | + for(i = 600; i < 1024; i++) { | |
| 128 | + memset(&sin, 0, sizeof(sin)); | |
| 129 | + sin.sin_family = AF_INET; | |
| 130 | + sin.sin_port = i; | |
| 131 | + | |
| 132 | + if(bind(fd, (struct sockaddr*)&sin, sizeof(sin)) >= 0) | |
| 133 | + return; | |
| 134 | + } | |
| 135 | + error(sys_errlist[errno]); | |
| 136 | + } | |
| 137 | + | |
| 138 | + memset(&sin, 0, sizeof(sin)); | |
| 139 | + sin.sin_family = AF_INET; | |
| 140 | + hnputs(&sin.sin_port, port); | |
| 141 | + | |
| 142 | + if(bind(fd, (struct sockaddr*)&sin, sizeof(sin)) < 0) | |
| 143 | + error(sys_errlist[errno]); | |
| 144 | +} | |
| 145 | + | |
| 146 | +int | |
| 147 | +so_gethostbyname(char *host, char**hostv, int n) | |
| 148 | +{ | |
| 149 | + int i; | |
| 150 | + char buf[32]; | |
| 151 | + unsigned char *p; | |
| 152 | + struct hostent *hp; | |
| 153 | + | |
| 154 | + hp = gethostbyname(host); | |
| 155 | + if(hp == 0) | |
| 156 | + return 0; | |
| 157 | + | |
| 158 | + for(i = 0; hp->h_addr_list[i] && i < n; i++) { | |
| 159 | + p = (unsigned char*)hp->h_addr_list[i]; | |
| 160 | + sprint(buf, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]); | |
| 161 | + hostv[i] = strdup(buf); | |
| 162 | + if(hostv[i] == 0) | |
| 163 | + break; | |
| 164 | + } | |
| 165 | + return i; | |
| 166 | +} | |
| 167 | + | |
| 168 | +char* | |
| 169 | +hostlookup(char *host) | |
| 170 | +{ | |
| 171 | + char buf[100]; | |
| 172 | + uchar *p; | |
| 173 | + HOSTENT *he; | |
| 174 | + | |
| 175 | + he = gethostbyname(host); | |
| 176 | + if(he != 0 && he->h_addr_list[0]) { | |
| 177 | + p = he->h_addr_list[0]; | |
| 178 | + sprint(buf, "%ud.%ud.%ud.%ud", p[0], p[1], p[2], p[3]); | |
| 179 | + } else | |
| 180 | + strcpy(buf, host); | |
| 181 | + | |
| 182 | + return strdup(buf); | |
| 183 | +} | |
| 184 | + | |
| 185 | +int | |
| 186 | +so_getservbyname(char *service, char *net, char *port) | |
| 187 | +{ | |
| 188 | + struct servent *s; | |
| 189 | + | |
| 190 | + s = getservbyname(service, net); | |
| 191 | + if(s == 0) | |
| 192 | + return -1; | |
| 193 | + | |
| 194 | + sprint(port, "%d", nhgets(&s->s_port)); | |
| 195 | + return 0; | |
| 196 | +} | |
| 197 | + | |
| 198 | +int | |
| 199 | +so_send(int fd, void *d, int n, int f) | |
| 200 | +{ | |
| 201 | + return send(fd, d, n, f); | |
| 202 | +} | |
| 203 | + | |
| 204 | +int | |
| 205 | +so_recv(int fd, void *d, int n, int f) | |
| 206 | +{ | |
| 207 | + return recv(fd, d, n, f); | |
| 208 | +} | |
| @@ -0,0 +1,936 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +#include "devip.h" | |
| 8 | + | |
| 9 | +void hnputl(void *p, unsigned long v); | |
| 10 | +void hnputs(void *p, unsigned short v); | |
| 11 | +unsigned long nhgetl(void *p); | |
| 12 | +unsigned short nhgets(void *p); | |
| 13 | +unsigned long parseip(char *to, char *from); | |
| 14 | +void csclose(Chan*); | |
| 15 | +long csread(Chan*, void*, long, vlong); | |
| 16 | +long cswrite(Chan*, void*, long, vlong); | |
| 17 | + | |
| 18 | +void osipinit(void); | |
| 19 | + | |
| 20 | +enum | |
| 21 | +{ | |
| 22 | + Qtopdir = 1, /* top level directory */ | |
| 23 | + Qcs, | |
| 24 | + Qprotodir, /* directory for a protocol */ | |
| 25 | + Qclonus, | |
| 26 | + Qconvdir, /* directory for a conversation */ | |
| 27 | + Qdata, | |
| 28 | + Qctl, | |
| 29 | + Qstatus, | |
| 30 | + Qremote, | |
| 31 | + Qlocal, | |
| 32 | + Qlisten, | |
| 33 | + | |
| 34 | + MAXPROTO = 4 | |
| 35 | +}; | |
| 36 | +#define TYPE(x) ((int)((x).path & 0xf)) | |
| 37 | +#define CONV(x) ((int)(((x).path >> 4)&0xfff)) | |
| 38 | +#define PROTO(x) ((int)(((x).path >> 16)&0xff)) | |
| 39 | +#define QID(p, c, y) (((p)<<16) | ((c)<<4) | (y)) | |
| 40 | + | |
| 41 | +typedef struct Proto Proto; | |
| 42 | +typedef struct Conv Conv; | |
| 43 | +struct Conv | |
| 44 | +{ | |
| 45 | + int x; | |
| 46 | + Ref r; | |
| 47 | + int sfd; | |
| 48 | + int perm; | |
| 49 | + char owner[KNAMELEN]; | |
| 50 | + char* state; | |
| 51 | + ulong laddr; | |
| 52 | + ushort lport; | |
| 53 | + ulong raddr; | |
| 54 | + ushort rport; | |
| 55 | + int restricted; | |
| 56 | + char cerr[KNAMELEN]; | |
| 57 | + Proto* p; | |
| 58 | +}; | |
| 59 | + | |
| 60 | +struct Proto | |
| 61 | +{ | |
| 62 | + Lock l; | |
| 63 | + int x; | |
| 64 | + int stype; | |
| 65 | + char name[KNAMELEN]; | |
| 66 | + int nc; | |
| 67 | + int maxconv; | |
| 68 | + Conv** conv; | |
| 69 | + Qid qid; | |
| 70 | +}; | |
| 71 | + | |
| 72 | +static int np; | |
| 73 | +static Proto proto[MAXPROTO]; | |
| 74 | +int eipfmt(Fmt*); | |
| 75 | + | |
| 76 | +static Conv* protoclone(Proto*, char*, int); | |
| 77 | +static void setladdr(Conv*); | |
| 78 | + | |
| 79 | +int | |
| 80 | +ipgen(Chan *c, char *nname, Dirtab *d, int nd, int s, Dir *dp) | |
| 81 | +{ | |
| 82 | + Qid q; | |
| 83 | + Conv *cv; | |
| 84 | + char *p; | |
| 85 | + | |
| 86 | + USED(nname); | |
| 87 | + q.vers = 0; | |
| 88 | + q.type = 0; | |
| 89 | + switch(TYPE(c->qid)) { | |
| 90 | + case Qtopdir: | |
| 91 | + if(s >= 1+np) | |
| 92 | + return -1; | |
| 93 | + | |
| 94 | + if(s == 0){ | |
| 95 | + q.path = QID(s, 0, Qcs); | |
| 96 | + devdir(c, q, "cs", 0, "network", 0666, dp); | |
| 97 | + }else{ | |
| 98 | + s--; | |
| 99 | + q.path = QID(s, 0, Qprotodir); | |
| 100 | + q.type = QTDIR; | |
| 101 | + devdir(c, q, proto[s].name, 0, "network", DMDIR|0555, dp); | |
| 102 | + } | |
| 103 | + return 1; | |
| 104 | + case Qprotodir: | |
| 105 | + if(s < proto[PROTO(c->qid)].nc) { | |
| 106 | + cv = proto[PROTO(c->qid)].conv[s]; | |
| 107 | + sprint(up->genbuf, "%d", s); | |
| 108 | + q.path = QID(PROTO(c->qid), s, Qconvdir); | |
| 109 | + q.type = QTDIR; | |
| 110 | + devdir(c, q, up->genbuf, 0, cv->owner, DMDIR|0555, dp); | |
| 111 | + return 1; | |
| 112 | + } | |
| 113 | + s -= proto[PROTO(c->qid)].nc; | |
| 114 | + switch(s) { | |
| 115 | + default: | |
| 116 | + return -1; | |
| 117 | + case 0: | |
| 118 | + p = "clone"; | |
| 119 | + q.path = QID(PROTO(c->qid), 0, Qclonus); | |
| 120 | + break; | |
| 121 | + } | |
| 122 | + devdir(c, q, p, 0, "network", 0555, dp); | |
| 123 | + return 1; | |
| 124 | + case Qconvdir: | |
| 125 | + cv = proto[PROTO(c->qid)].conv[CONV(c->qid)]; | |
| 126 | + switch(s) { | |
| 127 | + default: | |
| 128 | + return -1; | |
| 129 | + case 0: | |
| 130 | + q.path = QID(PROTO(c->qid), CONV(c->qid), Qdata); | |
| 131 | + devdir(c, q, "data", 0, cv->owner, cv->perm, dp); | |
| 132 | + return 1; | |
| 133 | + case 1: | |
| 134 | + q.path = QID(PROTO(c->qid), CONV(c->qid), Qctl); | |
| 135 | + devdir(c, q, "ctl", 0, cv->owner, cv->perm, dp); | |
| 136 | + return 1; | |
| 137 | + case 2: | |
| 138 | + p = "status"; | |
| 139 | + q.path = QID(PROTO(c->qid), CONV(c->qid), Qstatus); | |
| 140 | + break; | |
| 141 | + case 3: | |
| 142 | + p = "remote"; | |
| 143 | + q.path = QID(PROTO(c->qid), CONV(c->qid), Qremote); | |
| 144 | + break; | |
| 145 | + case 4: | |
| 146 | + p = "local"; | |
| 147 | + q.path = QID(PROTO(c->qid), CONV(c->qid), Qlocal); | |
| 148 | + break; | |
| 149 | + case 5: | |
| 150 | + p = "listen"; | |
| 151 | + q.path = QID(PROTO(c->qid), CONV(c->qid), Qlisten); | |
| 152 | + break; | |
| 153 | + } | |
| 154 | + devdir(c, q, p, 0, cv->owner, 0444, dp); | |
| 155 | + return 1; | |
| 156 | + } | |
| 157 | + return -1; | |
| 158 | +} | |
| 159 | + | |
| 160 | +static void | |
| 161 | +newproto(char *name, int type, int maxconv) | |
| 162 | +{ | |
| 163 | + int l; | |
| 164 | + Proto *p; | |
| 165 | + | |
| 166 | + if(np >= MAXPROTO) { | |
| 167 | + print("no %s: increase MAXPROTO", name); | |
| 168 | + return; | |
| 169 | + } | |
| 170 | + | |
| 171 | + p = &proto[np]; | |
| 172 | + strcpy(p->name, name); | |
| 173 | + p->stype = type; | |
| 174 | + p->qid.path = QID(np, 0, Qprotodir); | |
| 175 | + p->qid.type = QTDIR; | |
| 176 | + p->x = np++; | |
| 177 | + p->maxconv = maxconv; | |
| 178 | + l = sizeof(Conv*)*(p->maxconv+1); | |
| 179 | + p->conv = mallocz(l, 1); | |
| 180 | + if(p->conv == 0) | |
| 181 | + panic("no memory"); | |
| 182 | +} | |
| 183 | + | |
| 184 | +void | |
| 185 | +ipinit(void) | |
| 186 | +{ | |
| 187 | + osipinit(); | |
| 188 | + | |
| 189 | + newproto("udp", S_UDP, 10); | |
| 190 | + newproto("tcp", S_TCP, 30); | |
| 191 | + | |
| 192 | + fmtinstall('I', eipfmt); | |
| 193 | + fmtinstall('E', eipfmt); | |
| 194 | + | |
| 195 | +} | |
| 196 | + | |
| 197 | +Chan * | |
| 198 | +ipattach(char *spec) | |
| 199 | +{ | |
| 200 | + Chan *c; | |
| 201 | + | |
| 202 | + c = devattach('I', spec); | |
| 203 | + c->qid.path = QID(0, 0, Qtopdir); | |
| 204 | + c->qid.type = QTDIR; | |
| 205 | + c->qid.vers = 0; | |
| 206 | + return c; | |
| 207 | +} | |
| 208 | + | |
| 209 | +static Walkqid* | |
| 210 | +ipwalk(Chan *c, Chan *nc, char **name, int nname) | |
| 211 | +{ | |
| 212 | + return devwalk(c, nc, name, nname, 0, 0, ipgen); | |
| 213 | +} | |
| 214 | + | |
| 215 | +int | |
| 216 | +ipstat(Chan *c, uchar *dp, int n) | |
| 217 | +{ | |
| 218 | + return devstat(c, dp, n, 0, 0, ipgen); | |
| 219 | +} | |
| 220 | + | |
| 221 | +Chan * | |
| 222 | +ipopen(Chan *c, int omode) | |
| 223 | +{ | |
| 224 | + Proto *p; | |
| 225 | + ulong raddr; | |
| 226 | + ushort rport; | |
| 227 | + int perm, sfd; | |
| 228 | + Conv *cv, *lcv; | |
| 229 | + | |
| 230 | + omode &= 3; | |
| 231 | + switch(omode) { | |
| 232 | + case OREAD: | |
| 233 | + perm = 4; | |
| 234 | + break; | |
| 235 | + case OWRITE: | |
| 236 | + perm = 2; | |
| 237 | + break; | |
| 238 | + case ORDWR: | |
| 239 | + perm = 6; | |
| 240 | + break; | |
| 241 | + } | |
| 242 | + | |
| 243 | + switch(TYPE(c->qid)) { | |
| 244 | + default: | |
| 245 | + break; | |
| 246 | + case Qtopdir: | |
| 247 | + case Qprotodir: | |
| 248 | + case Qconvdir: | |
| 249 | + case Qstatus: | |
| 250 | + case Qremote: | |
| 251 | + case Qlocal: | |
| 252 | + if(omode != OREAD) | |
| 253 | + error(Eperm); | |
| 254 | + break; | |
| 255 | + case Qclonus: | |
| 256 | + p = &proto[PROTO(c->qid)]; | |
| 257 | + cv = protoclone(p, up->user, -1); | |
| 258 | + if(cv == 0) | |
| 259 | + error(Enodev); | |
| 260 | + c->qid.path = QID(p->x, cv->x, Qctl); | |
| 261 | + c->qid.vers = 0; | |
| 262 | + break; | |
| 263 | + case Qdata: | |
| 264 | + case Qctl: | |
| 265 | + p = &proto[PROTO(c->qid)]; | |
| 266 | + lock(&p->l); | |
| 267 | + cv = p->conv[CONV(c->qid)]; | |
| 268 | + lock(&cv->r.lk); | |
| 269 | + if((perm & (cv->perm>>6)) != perm) { | |
| 270 | + if(strcmp(up->user, cv->owner) != 0 || | |
| 271 | + (perm & cv->perm) != perm) { | |
| 272 | + unlock(&cv->r.lk); | |
| 273 | + unlock(&p->l); | |
| 274 | + error(Eperm); | |
| 275 | + } | |
| 276 | + } | |
| 277 | + cv->r.ref++; | |
| 278 | + if(cv->r.ref == 1) { | |
| 279 | + memmove(cv->owner, up->user, KNAMELEN); | |
| 280 | + cv->perm = 0660; | |
| 281 | + } | |
| 282 | + unlock(&cv->r.lk); | |
| 283 | + unlock(&p->l); | |
| 284 | + break; | |
| 285 | + case Qlisten: | |
| 286 | + p = &proto[PROTO(c->qid)]; | |
| 287 | + lcv = p->conv[CONV(c->qid)]; | |
| 288 | + sfd = so_accept(lcv->sfd, &raddr, &rport); | |
| 289 | + cv = protoclone(p, up->user, sfd); | |
| 290 | + if(cv == 0) { | |
| 291 | + close(sfd); | |
| 292 | + error(Enodev); | |
| 293 | + } | |
| 294 | + cv->raddr = raddr; | |
| 295 | + cv->rport = rport; | |
| 296 | + setladdr(cv); | |
| 297 | + cv->state = "Established"; | |
| 298 | + c->qid.path = QID(p->x, cv->x, Qctl); | |
| 299 | + break; | |
| 300 | + } | |
| 301 | + c->mode = openmode(omode); | |
| 302 | + c->flag |= COPEN; | |
| 303 | + c->offset = 0; | |
| 304 | + return c; | |
| 305 | +} | |
| 306 | + | |
| 307 | +void | |
| 308 | +ipclose(Chan *c) | |
| 309 | +{ | |
| 310 | + Conv *cc; | |
| 311 | + | |
| 312 | + switch(TYPE(c->qid)) { | |
| 313 | + case Qcs: | |
| 314 | + csclose(c); | |
| 315 | + break; | |
| 316 | + case Qdata: | |
| 317 | + case Qctl: | |
| 318 | + if((c->flag & COPEN) == 0) | |
| 319 | + break; | |
| 320 | + cc = proto[PROTO(c->qid)].conv[CONV(c->qid)]; | |
| 321 | + if(decref(&cc->r) != 0) | |
| 322 | + break; | |
| 323 | + strcpy(cc->owner, "network"); | |
| 324 | + cc->perm = 0666; | |
| 325 | + cc->state = "Closed"; | |
| 326 | + cc->laddr = 0; | |
| 327 | + cc->raddr = 0; | |
| 328 | + cc->lport = 0; | |
| 329 | + cc->rport = 0; | |
| 330 | + close(cc->sfd); | |
| 331 | + break; | |
| 332 | + } | |
| 333 | +} | |
| 334 | + | |
| 335 | +long | |
| 336 | +ipread(Chan *ch, void *a, long n, vlong offset) | |
| 337 | +{ | |
| 338 | + int r; | |
| 339 | + Conv *c; | |
| 340 | + Proto *x; | |
| 341 | + uchar ip[4]; | |
| 342 | + char buf[128], *p; | |
| 343 | + | |
| 344 | +/*print("ipread %s %lux\n", c2name(ch), (long)ch->qid.path);*/ | |
| 345 | + p = a; | |
| 346 | + switch(TYPE(ch->qid)) { | |
| 347 | + default: | |
| 348 | + error(Eperm); | |
| 349 | + case Qcs: | |
| 350 | + return csread(ch, a, n, offset); | |
| 351 | + case Qprotodir: | |
| 352 | + case Qtopdir: | |
| 353 | + case Qconvdir: | |
| 354 | + return devdirread(ch, a, n, 0, 0, ipgen); | |
| 355 | + case Qctl: | |
| 356 | + sprint(buf, "%d", CONV(ch->qid)); | |
| 357 | + return readstr(offset, p, n, buf); | |
| 358 | + case Qremote: | |
| 359 | + c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)]; | |
| 360 | + hnputl(ip, c->raddr); | |
| 361 | + sprint(buf, "%I!%d\n", ip, c->rport); | |
| 362 | + return readstr(offset, p, n, buf); | |
| 363 | + case Qlocal: | |
| 364 | + c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)]; | |
| 365 | + hnputl(ip, c->laddr); | |
| 366 | + sprint(buf, "%I!%d\n", ip, c->lport); | |
| 367 | + return readstr(offset, p, n, buf); | |
| 368 | + case Qstatus: | |
| 369 | + x = &proto[PROTO(ch->qid)]; | |
| 370 | + c = x->conv[CONV(ch->qid)]; | |
| 371 | + sprint(buf, "%s/%d %d %s \n", | |
| 372 | + c->p->name, c->x, c->r.ref, c->state); | |
| 373 | + return readstr(offset, p, n, buf); | |
| 374 | + case Qdata: | |
| 375 | + c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)]; | |
| 376 | + r = so_recv(c->sfd, a, n, 0); | |
| 377 | + if(r < 0){ | |
| 378 | + oserrstr(); | |
| 379 | + nexterror(); | |
| 380 | + } | |
| 381 | + return r; | |
| 382 | + } | |
| 383 | +} | |
| 384 | + | |
| 385 | +static void | |
| 386 | +setladdr(Conv *c) | |
| 387 | +{ | |
| 388 | + so_getsockname(c->sfd, &c->laddr, &c->lport); | |
| 389 | +} | |
| 390 | + | |
| 391 | +static void | |
| 392 | +setlport(Conv *c) | |
| 393 | +{ | |
| 394 | + if(c->restricted == 0 && c->lport == 0) | |
| 395 | + return; | |
| 396 | + | |
| 397 | + so_bind(c->sfd, c->restricted, c->lport); | |
| 398 | +} | |
| 399 | + | |
| 400 | +static void | |
| 401 | +setladdrport(Conv *c, char *str) | |
| 402 | +{ | |
| 403 | + char *p, addr[4]; | |
| 404 | + | |
| 405 | + p = strchr(str, '!'); | |
| 406 | + if(p == 0) { | |
| 407 | + p = str; | |
| 408 | + c->laddr = 0; | |
| 409 | + } | |
| 410 | + else { | |
| 411 | + *p++ = 0; | |
| 412 | + parseip(addr, str); | |
| 413 | + c->laddr = nhgetl((uchar*)addr); | |
| 414 | + } | |
| 415 | + if(*p == '*') | |
| 416 | + c->lport = 0; | |
| 417 | + else | |
| 418 | + c->lport = atoi(p); | |
| 419 | + | |
| 420 | + setlport(c); | |
| 421 | +} | |
| 422 | + | |
| 423 | +static char* | |
| 424 | +setraddrport(Conv *c, char *str) | |
| 425 | +{ | |
| 426 | + char *p, addr[4]; | |
| 427 | + | |
| 428 | + p = strchr(str, '!'); | |
| 429 | + if(p == 0) | |
| 430 | + return "malformed address"; | |
| 431 | + *p++ = 0; | |
| 432 | + parseip(addr, str); | |
| 433 | + c->raddr = nhgetl((uchar*)addr); | |
| 434 | + c->rport = atoi(p); | |
| 435 | + p = strchr(p, '!'); | |
| 436 | + if(p) { | |
| 437 | + if(strcmp(p, "!r") == 0) | |
| 438 | + c->restricted = 1; | |
| 439 | + } | |
| 440 | + return 0; | |
| 441 | +} | |
| 442 | + | |
| 443 | +long | |
| 444 | +ipwrite(Chan *ch, void *a, long n, vlong offset) | |
| 445 | +{ | |
| 446 | + Conv *c; | |
| 447 | + Proto *x; | |
| 448 | + int r, nf; | |
| 449 | + char *p, *fields[3], buf[128]; | |
| 450 | + | |
| 451 | + switch(TYPE(ch->qid)) { | |
| 452 | + default: | |
| 453 | + error(Eperm); | |
| 454 | + case Qcs: | |
| 455 | + return cswrite(ch, a, n, offset); | |
| 456 | + case Qctl: | |
| 457 | + x = &proto[PROTO(ch->qid)]; | |
| 458 | + c = x->conv[CONV(ch->qid)]; | |
| 459 | + if(n > sizeof(buf)-1) | |
| 460 | + n = sizeof(buf)-1; | |
| 461 | + memmove(buf, a, n); | |
| 462 | + buf[n] = '\0'; | |
| 463 | + | |
| 464 | + nf = tokenize(buf, fields, 3); | |
| 465 | + if(strcmp(fields[0], "connect") == 0){ | |
| 466 | + switch(nf) { | |
| 467 | + default: | |
| 468 | + error("bad args to connect"); | |
| 469 | + case 2: | |
| 470 | + p = setraddrport(c, fields[1]); | |
| 471 | + if(p != 0) | |
| 472 | + error(p); | |
| 473 | + break; | |
| 474 | + case 3: | |
| 475 | + p = setraddrport(c, fields[1]); | |
| 476 | + if(p != 0) | |
| 477 | + error(p); | |
| 478 | + c->lport = atoi(fields[2]); | |
| 479 | + setlport(c); | |
| 480 | + break; | |
| 481 | + } | |
| 482 | + so_connect(c->sfd, c->raddr, c->rport); | |
| 483 | + setladdr(c); | |
| 484 | + c->state = "Established"; | |
| 485 | + return n; | |
| 486 | + } | |
| 487 | + if(strcmp(fields[0], "announce") == 0) { | |
| 488 | + switch(nf){ | |
| 489 | + default: | |
| 490 | + error("bad args to announce"); | |
| 491 | + case 2: | |
| 492 | + setladdrport(c, fields[1]); | |
| 493 | + break; | |
| 494 | + } | |
| 495 | + so_listen(c->sfd); | |
| 496 | + c->state = "Announced"; | |
| 497 | + return n; | |
| 498 | + } | |
| 499 | + if(strcmp(fields[0], "bind") == 0){ | |
| 500 | + switch(nf){ | |
| 501 | + default: | |
| 502 | + error("bad args to bind"); | |
| 503 | + case 2: | |
| 504 | + c->lport = atoi(fields[1]); | |
| 505 | + break; | |
| 506 | + } | |
| 507 | + setlport(c); | |
| 508 | + return n; | |
| 509 | + } | |
| 510 | + error("bad control message"); | |
| 511 | + case Qdata: | |
| 512 | + x = &proto[PROTO(ch->qid)]; | |
| 513 | + c = x->conv[CONV(ch->qid)]; | |
| 514 | + r = so_send(c->sfd, a, n, 0); | |
| 515 | + if(r < 0){ | |
| 516 | + oserrstr(); | |
| 517 | + nexterror(); | |
| 518 | + } | |
| 519 | + return r; | |
| 520 | + } | |
| 521 | + return n; | |
| 522 | +} | |
| 523 | + | |
| 524 | +static Conv* | |
| 525 | +protoclone(Proto *p, char *user, int nfd) | |
| 526 | +{ | |
| 527 | + Conv *c, **pp, **ep; | |
| 528 | + | |
| 529 | + c = 0; | |
| 530 | + lock(&p->l); | |
| 531 | + if(waserror()) { | |
| 532 | + unlock(&p->l); | |
| 533 | + nexterror(); | |
| 534 | + } | |
| 535 | + ep = &p->conv[p->maxconv]; | |
| 536 | + for(pp = p->conv; pp < ep; pp++) { | |
| 537 | + c = *pp; | |
| 538 | + if(c == 0) { | |
| 539 | + c = mallocz(sizeof(Conv), 1); | |
| 540 | + if(c == 0) | |
| 541 | + error(Enomem); | |
| 542 | + lock(&c->r.lk); | |
| 543 | + c->r.ref = 1; | |
| 544 | + c->p = p; | |
| 545 | + c->x = pp - p->conv; | |
| 546 | + p->nc++; | |
| 547 | + *pp = c; | |
| 548 | + break; | |
| 549 | + } | |
| 550 | + lock(&c->r.lk); | |
| 551 | + if(c->r.ref == 0) { | |
| 552 | + c->r.ref++; | |
| 553 | + break; | |
| 554 | + } | |
| 555 | + unlock(&c->r.lk); | |
| 556 | + } | |
| 557 | + if(pp >= ep) { | |
| 558 | + unlock(&p->l); | |
| 559 | + poperror(); | |
| 560 | + return 0; | |
| 561 | + } | |
| 562 | + | |
| 563 | + strcpy(c->owner, user); | |
| 564 | + c->perm = 0660; | |
| 565 | + c->state = "Closed"; | |
| 566 | + c->restricted = 0; | |
| 567 | + c->laddr = 0; | |
| 568 | + c->raddr = 0; | |
| 569 | + c->lport = 0; | |
| 570 | + c->rport = 0; | |
| 571 | + c->sfd = nfd; | |
| 572 | + if(nfd == -1) | |
| 573 | + c->sfd = so_socket(p->stype); | |
| 574 | + | |
| 575 | + unlock(&c->r.lk); | |
| 576 | + unlock(&p->l); | |
| 577 | + poperror(); | |
| 578 | + return c; | |
| 579 | +} | |
| 580 | + | |
| 581 | +enum | |
| 582 | +{ | |
| 583 | + Isprefix= 16, | |
| 584 | +}; | |
| 585 | + | |
| 586 | +uchar prefixvals[256] = | |
| 587 | +{ | |
| 588 | +/*0x00*/ 0 | Isprefix, | |
| 589 | + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 590 | +/*0x10*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 591 | +/*0x20*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 592 | +/*0x30*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 593 | +/*0x40*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 594 | +/*0x50*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 595 | +/*0x60*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 596 | +/*0x70*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 597 | +/*0x80*/ 1 | Isprefix, | |
| 598 | + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 599 | +/*0x90*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 600 | +/*0xA0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 601 | +/*0xB0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 602 | +/*0xC0*/ 2 | Isprefix, | |
| 603 | + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 604 | +/*0xD0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 605 | +/*0xE0*/ 3 | Isprefix, | |
| 606 | + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 607 | +/*0xF0*/ 4 | Isprefix, | |
| 608 | + 0, 0, 0, 0, 0, 0, 0, | |
| 609 | +/*0xF8*/ 5 | Isprefix, | |
| 610 | + 0, 0, 0, | |
| 611 | +/*0xFC*/ 6 | Isprefix, | |
| 612 | + 0, | |
| 613 | +/*0xFE*/ 7 | Isprefix, | |
| 614 | +/*0xFF*/ 8 | Isprefix, | |
| 615 | +}; | |
| 616 | + | |
| 617 | +int | |
| 618 | +eipfmt(Fmt *f) | |
| 619 | +{ | |
| 620 | + char buf[5*8]; | |
| 621 | + static char *efmt = "%.2lux%.2lux%.2lux%.2lux%.2lux%.2lux"; | |
| 622 | + static char *ifmt = "%d.%d.%d.%d"; | |
| 623 | + uchar *p, ip[16]; | |
| 624 | + ulong *lp; | |
| 625 | + ushort s; | |
| 626 | + int i, j, n, eln, eli; | |
| 627 | + ulong ul; | |
| 628 | + | |
| 629 | + switch(f->r) { | |
| 630 | + case 'E': /* Ethernet address */ | |
| 631 | + p = va_arg(f->args, uchar*); | |
| 632 | + snprint(buf, sizeof buf, efmt, p[0], p[1], p[2], p[3], p[4], p[5]); | |
| 633 | + return fmtstrcpy(f, buf); | |
| 634 | + | |
| 635 | + case 'I': | |
| 636 | + ul = va_arg(f->args, ulong); | |
| 637 | + hnputl(ip, ul); | |
| 638 | + snprint(buf, sizeof buf, ifmt, ip[0], ip[1], ip[2], ip[3]); | |
| 639 | + return fmtstrcpy(f, buf); | |
| 640 | + } | |
| 641 | + return fmtstrcpy(f, "(eipfmt)"); | |
| 642 | +} | |
| 643 | + | |
| 644 | +void | |
| 645 | +hnputl(void *p, unsigned long v) | |
| 646 | +{ | |
| 647 | + unsigned char *a; | |
| 648 | + | |
| 649 | + a = p; | |
| 650 | + a[0] = v>>24; | |
| 651 | + a[1] = v>>16; | |
| 652 | + a[2] = v>>8; | |
| 653 | + a[3] = v; | |
| 654 | +} | |
| 655 | + | |
| 656 | +void | |
| 657 | +hnputs(void *p, unsigned short v) | |
| 658 | +{ | |
| 659 | + unsigned char *a; | |
| 660 | + | |
| 661 | + a = p; | |
| 662 | + a[0] = v>>8; | |
| 663 | + a[1] = v; | |
| 664 | +} | |
| 665 | + | |
| 666 | +unsigned long | |
| 667 | +nhgetl(void *p) | |
| 668 | +{ | |
| 669 | + unsigned char *a; | |
| 670 | + a = p; | |
| 671 | + return (a[0]<<24)|(a[1]<<16)|(a[2]<<8)|(a[3]<<0); | |
| 672 | +} | |
| 673 | + | |
| 674 | +unsigned short | |
| 675 | +nhgets(void *p) | |
| 676 | +{ | |
| 677 | + unsigned char *a; | |
| 678 | + a = p; | |
| 679 | + return (a[0]<<8)|(a[1]<<0); | |
| 680 | +} | |
| 681 | + | |
| 682 | +#define CLASS(p) ((*(unsigned char*)(p))>>6) | |
| 683 | + | |
| 684 | +unsigned long | |
| 685 | +parseip(char *to, char *from) | |
| 686 | +{ | |
| 687 | + int i; | |
| 688 | + char *p; | |
| 689 | + | |
| 690 | + p = from; | |
| 691 | + memset(to, 0, 4); | |
| 692 | + for(i = 0; i < 4 && *p; i++){ | |
| 693 | + to[i] = strtoul(p, &p, 0); | |
| 694 | + if(*p == '.') | |
| 695 | + p++; | |
| 696 | + } | |
| 697 | + switch(CLASS(to)){ | |
| 698 | + case 0: /* class A - 1 byte net */ | |
| 699 | + case 1: | |
| 700 | + if(i == 3){ | |
| 701 | + to[3] = to[2]; | |
| 702 | + to[2] = to[1]; | |
| 703 | + to[1] = 0; | |
| 704 | + } else if (i == 2){ | |
| 705 | + to[3] = to[1]; | |
| 706 | + to[1] = 0; | |
| 707 | + } | |
| 708 | + break; | |
| 709 | + case 2: /* class B - 2 byte net */ | |
| 710 | + if(i == 3){ | |
| 711 | + to[3] = to[2]; | |
| 712 | + to[2] = 0; | |
| 713 | + } | |
| 714 | + break; | |
| 715 | + } | |
| 716 | + return nhgetl(to); | |
| 717 | +} | |
| 718 | + | |
| 719 | +void | |
| 720 | +csclose(Chan *c) | |
| 721 | +{ | |
| 722 | + free(c->aux); | |
| 723 | +} | |
| 724 | + | |
| 725 | +long | |
| 726 | +csread(Chan *c, void *a, long n, vlong offset) | |
| 727 | +{ | |
| 728 | + if(c->aux == nil) | |
| 729 | + return 0; | |
| 730 | + return readstr(offset, a, n, c->aux); | |
| 731 | +} | |
| 732 | + | |
| 733 | +static struct | |
| 734 | +{ | |
| 735 | + char *name; | |
| 736 | + uint num; | |
| 737 | +} tab[] = { | |
| 738 | + "cs", 1, | |
| 739 | + "echo", 7, | |
| 740 | + "discard", 9, | |
| 741 | + "systat", 11, | |
| 742 | + "daytime", 13, | |
| 743 | + "netstat", 15, | |
| 744 | + "chargen", 19, | |
| 745 | + "ftp-data", 20, | |
| 746 | + "ftp", 21, | |
| 747 | + "ssh", 22, | |
| 748 | + "telnet", 23, | |
| 749 | + "smtp", 25, | |
| 750 | + "time", 37, | |
| 751 | + "whois", 43, | |
| 752 | + "dns", 53, | |
| 753 | + "domain", 53, | |
| 754 | + "uucp", 64, | |
| 755 | + "gopher", 70, | |
| 756 | + "rje", 77, | |
| 757 | + "finger", 79, | |
| 758 | + "http", 80, | |
| 759 | + "link", 87, | |
| 760 | + "supdup", 95, | |
| 761 | + "hostnames", 101, | |
| 762 | + "iso-tsap", 102, | |
| 763 | + "x400", 103, | |
| 764 | + "x400-snd", 104, | |
| 765 | + "csnet-ns", 105, | |
| 766 | + "pop-2", 109, | |
| 767 | + "pop3", 110, | |
| 768 | + "portmap", 111, | |
| 769 | + "uucp-path", 117, | |
| 770 | + "nntp", 119, | |
| 771 | + "netbios", 139, | |
| 772 | + "imap4", 143, | |
| 773 | + "NeWS", 144, | |
| 774 | + "print-srv", 170, | |
| 775 | + "z39.50", 210, | |
| 776 | + "fsb", 400, | |
| 777 | + "sysmon", 401, | |
| 778 | + "proxy", 402, | |
| 779 | + "proxyd", 404, | |
| 780 | + "https", 443, | |
| 781 | + "cifs", 445, | |
| 782 | + "ssmtp", 465, | |
| 783 | + "rexec", 512, | |
| 784 | + "login", 513, | |
| 785 | + "shell", 514, | |
| 786 | + "printer", 515, | |
| 787 | + "courier", 530, | |
| 788 | + "cscan", 531, | |
| 789 | + "uucp", 540, | |
| 790 | + "snntp", 563, | |
| 791 | + "9fs", 564, | |
| 792 | + "whoami", 565, | |
| 793 | + "guard", 566, | |
| 794 | + "ticket", 567, | |
| 795 | + "dlsftp", 666, | |
| 796 | + "fmclient", 729, | |
| 797 | + "imaps", 993, | |
| 798 | + "pop3s", 995, | |
| 799 | + "ingreslock", 1524, | |
| 800 | + "pptp", 1723, | |
| 801 | + "nfs", 2049, | |
| 802 | + "webster", 2627, | |
| 803 | + "weather", 3000, | |
| 804 | + "secstore", 5356, | |
| 805 | + "Xdisplay", 6000, | |
| 806 | + "styx", 6666, | |
| 807 | + "mpeg", 6667, | |
| 808 | + "rstyx", 6668, | |
| 809 | + "infdb", 6669, | |
| 810 | + "infsigner", 6671, | |
| 811 | + "infcsigner", 6672, | |
| 812 | + "inflogin", 6673, | |
| 813 | + "bandt", 7330, | |
| 814 | + "face", 32000, | |
| 815 | + "dhashgate", 11978, | |
| 816 | + "exportfs", 17007, | |
| 817 | + "rexexec", 17009, | |
| 818 | + "ncpu", 17010, | |
| 819 | + "cpu", 17013, | |
| 820 | + "glenglenda1", 17020, | |
| 821 | + "glenglenda2", 17021, | |
| 822 | + "glenglenda3", 17022, | |
| 823 | + "glenglenda4", 17023, | |
| 824 | + "glenglenda5", 17024, | |
| 825 | + "glenglenda6", 17025, | |
| 826 | + "glenglenda7", 17026, | |
| 827 | + "glenglenda8", 17027, | |
| 828 | + "glenglenda9", 17028, | |
| 829 | + "glenglenda10", 17029, | |
| 830 | + "flyboy", 17032, | |
| 831 | + "dlsftp", 17033, | |
| 832 | + "venti", 17034, | |
| 833 | + "wiki", 17035, | |
| 834 | + "vica", 17036, | |
| 835 | + 0 | |
| 836 | +}; | |
| 837 | + | |
| 838 | +static int | |
| 839 | +lookupport(char *s) | |
| 840 | +{ | |
| 841 | + int i; | |
| 842 | + char buf[10], *p; | |
| 843 | + | |
| 844 | + i = strtol(s, &p, 0); | |
| 845 | + if(*s && *p == 0) | |
| 846 | + return i; | |
| 847 | + | |
| 848 | + i = so_getservbyname(s, "tcp", buf); | |
| 849 | + if(i != -1) | |
| 850 | + return atoi(buf); | |
| 851 | + for(i=0; tab[i].name; i++) | |
| 852 | + if(strcmp(s, tab[i].name) == 0) | |
| 853 | + return tab[i].num; | |
| 854 | + return 0; | |
| 855 | +} | |
| 856 | + | |
| 857 | +static ulong | |
| 858 | +lookuphost(char *s) | |
| 859 | +{ | |
| 860 | + char to[4]; | |
| 861 | + ulong ip; | |
| 862 | + | |
| 863 | + memset(to, 0, sizeof to); | |
| 864 | + parseip(to, s); | |
| 865 | + ip = nhgetl(to); | |
| 866 | + if(ip != 0) | |
| 867 | + return ip; | |
| 868 | + if((s = hostlookup(s)) == nil) | |
| 869 | + return 0; | |
| 870 | + parseip(to, s); | |
| 871 | + ip = nhgetl(to); | |
| 872 | + free(s); | |
| 873 | + return ip; | |
| 874 | +} | |
| 875 | + | |
| 876 | +long | |
| 877 | +cswrite(Chan *c, void *a, long n, vlong offset) | |
| 878 | +{ | |
| 879 | + char *f[4]; | |
| 880 | + char *s, *ns; | |
| 881 | + ulong ip; | |
| 882 | + int nf, port; | |
| 883 | + | |
| 884 | + s = malloc(n+1); | |
| 885 | + if(s == nil) | |
| 886 | + error(Enomem); | |
| 887 | + if(waserror()){ | |
| 888 | + free(s); | |
| 889 | + nexterror(); | |
| 890 | + } | |
| 891 | + memmove(s, a, n); | |
| 892 | + s[n] = 0; | |
| 893 | + nf = getfields(s, f, nelem(f), 0, "!"); | |
| 894 | + if(nf != 3) | |
| 895 | + error("can't translate"); | |
| 896 | + | |
| 897 | + port = lookupport(f[2]); | |
| 898 | + if(port <= 0) | |
| 899 | + error("no translation for port found"); | |
| 900 | + | |
| 901 | + ip = lookuphost(f[1]); | |
| 902 | + if(ip == 0) | |
| 903 | + error("no translation for host found"); | |
| 904 | + | |
| 905 | + ns = smprint("/net/%s/clone %I!%d", f[0], ip, port); | |
| 906 | + if(ns == nil) | |
| 907 | + error(Enomem); | |
| 908 | + free(c->aux); | |
| 909 | + c->aux = ns; | |
| 910 | + poperror(); | |
| 911 | + free(s); | |
| 912 | + return n; | |
| 913 | +} | |
| 914 | + | |
| 915 | +Dev ipdevtab = | |
| 916 | +{ | |
| 917 | + 'I', | |
| 918 | + "ip", | |
| 919 | + | |
| 920 | + devreset, | |
| 921 | + ipinit, | |
| 922 | + devshutdown, | |
| 923 | + ipattach, | |
| 924 | + ipwalk, | |
| 925 | + ipstat, | |
| 926 | + ipopen, | |
| 927 | + devcreate, | |
| 928 | + ipclose, | |
| 929 | + ipread, | |
| 930 | + devbread, | |
| 931 | + ipwrite, | |
| 932 | + devbwrite, | |
| 933 | + devremove, | |
| 934 | + devwstat, | |
| 935 | +}; | |
| 936 | + | |
| @@ -0,0 +1,17 @@ | ||
| 1 | +enum | |
| 2 | +{ | |
| 3 | + S_TCP, | |
| 4 | + S_UDP | |
| 5 | +}; | |
| 6 | + | |
| 7 | +int so_socket(int type); | |
| 8 | +void so_connect(int, unsigned long, unsigned short); | |
| 9 | +void so_getsockname(int, unsigned long*, unsigned short*); | |
| 10 | +void so_bind(int, int, unsigned short); | |
| 11 | +void so_listen(int); | |
| 12 | +int so_accept(int, unsigned long*, unsigned short*); | |
| 13 | +int so_getservbyname(char*, char*, char*); | |
| 14 | +int so_gethostbyname(char*, char**, int); | |
| 15 | + | |
| 16 | +char* hostlookup(char*); | |
| 17 | + | |
| @@ -0,0 +1,1214 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +/* | |
| 8 | + * References are managed as follows: | |
| 9 | + * The channel to the server - a network connection or pipe - has one | |
| 10 | + * reference for every Chan open on the server. The server channel has | |
| 11 | + * c->mux set to the Mnt used for muxing control to that server. Mnts | |
| 12 | + * have no reference count; they go away when c goes away. | |
| 13 | + * Each channel derived from the mount point has mchan set to c, | |
| 14 | + * and increfs/decrefs mchan to manage references on the server | |
| 15 | + * connection. | |
| 16 | + */ | |
| 17 | + | |
| 18 | +#define MAXRPC (IOHDRSZ+8192) | |
| 19 | + | |
| 20 | +struct Mntrpc | |
| 21 | +{ | |
| 22 | + Chan* c; /* Channel for whom we are working */ | |
| 23 | + Mntrpc* list; /* Free/pending list */ | |
| 24 | + Fcall request; /* Outgoing file system protocol message */ | |
| 25 | + Fcall reply; /* Incoming reply */ | |
| 26 | + Mnt* m; /* Mount device during rpc */ | |
| 27 | + Rendez r; /* Place to hang out */ | |
| 28 | + uchar* rpc; /* I/O Data buffer */ | |
| 29 | + uint rpclen; /* len of buffer */ | |
| 30 | + Block *b; /* reply blocks */ | |
| 31 | + char done; /* Rpc completed */ | |
| 32 | + uvlong stime; /* start time for mnt statistics */ | |
| 33 | + ulong reqlen; /* request length for mnt statistics */ | |
| 34 | + ulong replen; /* reply length for mnt statistics */ | |
| 35 | + Mntrpc* flushed; /* message this one flushes */ | |
| 36 | +}; | |
| 37 | + | |
| 38 | +enum | |
| 39 | +{ | |
| 40 | + TAGSHIFT = 5, /* ulong has to be 32 bits */ | |
| 41 | + TAGMASK = (1<<TAGSHIFT)-1, | |
| 42 | + NMASK = (64*1024)>>TAGSHIFT, | |
| 43 | +}; | |
| 44 | + | |
| 45 | +struct Mntalloc | |
| 46 | +{ | |
| 47 | + Lock lk; | |
| 48 | + Mnt* list; /* Mount devices in use */ | |
| 49 | + Mnt* mntfree; /* Free list */ | |
| 50 | + Mntrpc* rpcfree; | |
| 51 | + int nrpcfree; | |
| 52 | + int nrpcused; | |
| 53 | + ulong id; | |
| 54 | + ulong tagmask[NMASK]; | |
| 55 | +}mntalloc; | |
| 56 | + | |
| 57 | +void mattach(Mnt*, Chan*, char*); | |
| 58 | +Mnt* mntchk(Chan*); | |
| 59 | +void mntdirfix(uchar*, Chan*); | |
| 60 | +Mntrpc* mntflushalloc(Mntrpc*, ulong); | |
| 61 | +void mntflushfree(Mnt*, Mntrpc*); | |
| 62 | +void mntfree(Mntrpc*); | |
| 63 | +void mntgate(Mnt*); | |
| 64 | +void mntpntfree(Mnt*); | |
| 65 | +void mntqrm(Mnt*, Mntrpc*); | |
| 66 | +Mntrpc* mntralloc(Chan*, ulong); | |
| 67 | +long mntrdwr(int, Chan*, void*, long, vlong); | |
| 68 | +int mntrpcread(Mnt*, Mntrpc*); | |
| 69 | +void mountio(Mnt*, Mntrpc*); | |
| 70 | +void mountmux(Mnt*, Mntrpc*); | |
| 71 | +void mountrpc(Mnt*, Mntrpc*); | |
| 72 | +int rpcattn(void*); | |
| 73 | +Chan* mntchan(void); | |
| 74 | + | |
| 75 | +char Esbadstat[] = "invalid directory entry received from server"; | |
| 76 | +char Enoversion[] = "version not established for mount channel"; | |
| 77 | + | |
| 78 | + | |
| 79 | +void (*mntstats)(int, Chan*, uvlong, ulong); | |
| 80 | + | |
| 81 | +static void | |
| 82 | +mntreset(void) | |
| 83 | +{ | |
| 84 | + mntalloc.id = 1; | |
| 85 | + mntalloc.tagmask[0] = 1; /* don't allow 0 as a tag */ | |
| 86 | + mntalloc.tagmask[NMASK-1] = 0x80000000UL; /* don't allow NOTAG */ | |
| 87 | + fmtinstall('F', fcallfmt); | |
| 88 | + fmtinstall('D', dirfmt); | |
| 89 | +/* We can't install %M since eipfmt does and is used in the kernel [sape] */ | |
| 90 | + | |
| 91 | + cinit(); | |
| 92 | +} | |
| 93 | + | |
| 94 | +/* | |
| 95 | + * Version is not multiplexed: message sent only once per connection. | |
| 96 | + */ | |
| 97 | +long | |
| 98 | +mntversion(Chan *c, char *version, int msize, int returnlen) | |
| 99 | +{ | |
| 100 | + Fcall f; | |
| 101 | + uchar *msg; | |
| 102 | + Mnt *m; | |
| 103 | + char *v; | |
| 104 | + long k, l; | |
| 105 | + uvlong oo; | |
| 106 | + char buf[128]; | |
| 107 | + | |
| 108 | + qlock(&c->umqlock); /* make sure no one else does this until we've established ourselves */ | |
| 109 | + if(waserror()){ | |
| 110 | + qunlock(&c->umqlock); | |
| 111 | + nexterror(); | |
| 112 | + } | |
| 113 | + | |
| 114 | + /* defaults */ | |
| 115 | + if(msize == 0) | |
| 116 | + msize = MAXRPC; | |
| 117 | + if(msize > c->iounit && c->iounit != 0) | |
| 118 | + msize = c->iounit; | |
| 119 | + v = version; | |
| 120 | + if(v == nil || v[0] == '\0') | |
| 121 | + v = VERSION9P; | |
| 122 | + | |
| 123 | + /* validity */ | |
| 124 | + if(msize < 0) | |
| 125 | + error("bad iounit in version call"); | |
| 126 | + if(strncmp(v, VERSION9P, strlen(VERSION9P)) != 0) | |
| 127 | + error("bad 9P version specification"); | |
| 128 | + | |
| 129 | + m = c->mux; | |
| 130 | + | |
| 131 | + if(m != nil){ | |
| 132 | + qunlock(&c->umqlock); | |
| 133 | + poperror(); | |
| 134 | + | |
| 135 | + strecpy(buf, buf+sizeof buf, m->version); | |
| 136 | + k = strlen(buf); | |
| 137 | + if(strncmp(buf, v, k) != 0){ | |
| 138 | + snprint(buf, sizeof buf, "incompatible 9P versions %s %s", m->version, v); | |
| 139 | + error(buf); | |
| 140 | + } | |
| 141 | + if(returnlen > 0){ | |
| 142 | + if(returnlen < k) | |
| 143 | + error(Eshort); | |
| 144 | + memmove(version, buf, k); | |
| 145 | + } | |
| 146 | + return k; | |
| 147 | + } | |
| 148 | + | |
| 149 | + f.type = Tversion; | |
| 150 | + f.tag = NOTAG; | |
| 151 | + f.msize = msize; | |
| 152 | + f.version = v; | |
| 153 | + msg = malloc(8192+IOHDRSZ); | |
| 154 | + if(msg == nil) | |
| 155 | + exhausted("version memory"); | |
| 156 | + if(waserror()){ | |
| 157 | + free(msg); | |
| 158 | + nexterror(); | |
| 159 | + } | |
| 160 | + k = convS2M(&f, msg, 8192+IOHDRSZ); | |
| 161 | + if(k == 0) | |
| 162 | + error("bad fversion conversion on send"); | |
| 163 | + | |
| 164 | + lock(&c->ref.lk); | |
| 165 | + oo = c->offset; | |
| 166 | + c->offset += k; | |
| 167 | + unlock(&c->ref.lk); | |
| 168 | + | |
| 169 | + l = devtab[c->type]->write(c, msg, k, oo); | |
| 170 | + | |
| 171 | + if(l < k){ | |
| 172 | + lock(&c->ref.lk); | |
| 173 | + c->offset -= k - l; | |
| 174 | + unlock(&c->ref.lk); | |
| 175 | + error("short write in fversion"); | |
| 176 | + } | |
| 177 | + | |
| 178 | + /* message sent; receive and decode reply */ | |
| 179 | + k = devtab[c->type]->read(c, msg, 8192+IOHDRSZ, c->offset); | |
| 180 | + if(k <= 0) | |
| 181 | + error("EOF receiving fversion reply"); | |
| 182 | + | |
| 183 | + lock(&c->ref.lk); | |
| 184 | + c->offset += k; | |
| 185 | + unlock(&c->ref.lk); | |
| 186 | + | |
| 187 | + l = convM2S(msg, k, &f); | |
| 188 | + if(l != k) | |
| 189 | + error("bad fversion conversion on reply"); | |
| 190 | + if(f.type != Rversion){ | |
| 191 | + if(f.type == Rerror) | |
| 192 | + error(f.ename); | |
| 193 | + error("unexpected reply type in fversion"); | |
| 194 | + } | |
| 195 | + if(f.msize > msize) | |
| 196 | + error("server tries to increase msize in fversion"); | |
| 197 | + if(f.msize<256 || f.msize>1024*1024) | |
| 198 | + error("nonsense value of msize in fversion"); | |
| 199 | + if(strncmp(f.version, v, strlen(f.version)) != 0) | |
| 200 | + error("bad 9P version returned from server"); | |
| 201 | + | |
| 202 | + /* now build Mnt associated with this connection */ | |
| 203 | + lock(&mntalloc.lk); | |
| 204 | + m = mntalloc.mntfree; | |
| 205 | + if(m != 0) | |
| 206 | + mntalloc.mntfree = m->list; | |
| 207 | + else { | |
| 208 | + m = malloc(sizeof(Mnt)); | |
| 209 | + if(m == 0) { | |
| 210 | + unlock(&mntalloc.lk); | |
| 211 | + exhausted("mount devices"); | |
| 212 | + } | |
| 213 | + } | |
| 214 | + m->list = mntalloc.list; | |
| 215 | + mntalloc.list = m; | |
| 216 | + m->version = nil; | |
| 217 | + kstrdup(&m->version, f.version); | |
| 218 | + m->id = mntalloc.id++; | |
| 219 | + m->q = qopen(10*MAXRPC, 0, nil, nil); | |
| 220 | + m->msize = f.msize; | |
| 221 | + unlock(&mntalloc.lk); | |
| 222 | + | |
| 223 | + poperror(); /* msg */ | |
| 224 | + free(msg); | |
| 225 | + | |
| 226 | + lock(&m->lk); | |
| 227 | + m->queue = 0; | |
| 228 | + m->rip = 0; | |
| 229 | + | |
| 230 | + c->flag |= CMSG; | |
| 231 | + c->mux = m; | |
| 232 | + m->c = c; | |
| 233 | + unlock(&m->lk); | |
| 234 | + | |
| 235 | + poperror(); /* c */ | |
| 236 | + qunlock(&c->umqlock); | |
| 237 | + | |
| 238 | + k = strlen(f.version); | |
| 239 | + if(returnlen > 0){ | |
| 240 | + if(returnlen < k) | |
| 241 | + error(Eshort); | |
| 242 | + memmove(version, f.version, k); | |
| 243 | + } | |
| 244 | + | |
| 245 | + return k; | |
| 246 | +} | |
| 247 | + | |
| 248 | +Chan* | |
| 249 | +mntauth(Chan *c, char *spec) | |
| 250 | +{ | |
| 251 | + Mnt *m; | |
| 252 | + Mntrpc *r; | |
| 253 | + | |
| 254 | + m = c->mux; | |
| 255 | + | |
| 256 | + if(m == nil){ | |
| 257 | + mntversion(c, VERSION9P, MAXRPC, 0); | |
| 258 | + m = c->mux; | |
| 259 | + if(m == nil) | |
| 260 | + error(Enoversion); | |
| 261 | + } | |
| 262 | + | |
| 263 | + c = mntchan(); | |
| 264 | + if(waserror()) { | |
| 265 | + /* Close must not be called since it will | |
| 266 | + * call mnt recursively | |
| 267 | + */ | |
| 268 | + chanfree(c); | |
| 269 | + nexterror(); | |
| 270 | + } | |
| 271 | + | |
| 272 | + r = mntralloc(0, m->msize); | |
| 273 | + | |
| 274 | + if(waserror()) { | |
| 275 | + mntfree(r); | |
| 276 | + nexterror(); | |
| 277 | + } | |
| 278 | + | |
| 279 | + r->request.type = Tauth; | |
| 280 | + r->request.afid = c->fid; | |
| 281 | + r->request.uname = up->user; | |
| 282 | + r->request.aname = spec; | |
| 283 | + mountrpc(m, r); | |
| 284 | + | |
| 285 | + c->qid = r->reply.aqid; | |
| 286 | + c->mchan = m->c; | |
| 287 | + incref(&m->c->ref); | |
| 288 | + c->mqid = c->qid; | |
| 289 | + c->mode = ORDWR; | |
| 290 | + | |
| 291 | + poperror(); /* r */ | |
| 292 | + mntfree(r); | |
| 293 | + | |
| 294 | + poperror(); /* c */ | |
| 295 | + | |
| 296 | + return c; | |
| 297 | + | |
| 298 | +} | |
| 299 | + | |
| 300 | +static Chan* | |
| 301 | +mntattach(char *muxattach) | |
| 302 | +{ | |
| 303 | + Mnt *m; | |
| 304 | + Chan *c; | |
| 305 | + Mntrpc *r; | |
| 306 | + struct bogus{ | |
| 307 | + Chan *chan; | |
| 308 | + Chan *authchan; | |
| 309 | + char *spec; | |
| 310 | + int flags; | |
| 311 | + }bogus; | |
| 312 | + | |
| 313 | + bogus = *((struct bogus *)muxattach); | |
| 314 | + c = bogus.chan; | |
| 315 | + | |
| 316 | + m = c->mux; | |
| 317 | + | |
| 318 | + if(m == nil){ | |
| 319 | + mntversion(c, nil, 0, 0); | |
| 320 | + m = c->mux; | |
| 321 | + if(m == nil) | |
| 322 | + error(Enoversion); | |
| 323 | + } | |
| 324 | + | |
| 325 | + c = mntchan(); | |
| 326 | + if(waserror()) { | |
| 327 | + /* Close must not be called since it will | |
| 328 | + * call mnt recursively | |
| 329 | + */ | |
| 330 | + chanfree(c); | |
| 331 | + nexterror(); | |
| 332 | + } | |
| 333 | + | |
| 334 | + r = mntralloc(0, m->msize); | |
| 335 | + | |
| 336 | + if(waserror()) { | |
| 337 | + mntfree(r); | |
| 338 | + nexterror(); | |
| 339 | + } | |
| 340 | + | |
| 341 | + r->request.type = Tattach; | |
| 342 | + r->request.fid = c->fid; | |
| 343 | + if(bogus.authchan == nil) | |
| 344 | + r->request.afid = NOFID; | |
| 345 | + else | |
| 346 | + r->request.afid = bogus.authchan->fid; | |
| 347 | + r->request.uname = up->user; | |
| 348 | + r->request.aname = bogus.spec; | |
| 349 | + mountrpc(m, r); | |
| 350 | + | |
| 351 | + c->qid = r->reply.qid; | |
| 352 | + c->mchan = m->c; | |
| 353 | + incref(&m->c->ref); | |
| 354 | + c->mqid = c->qid; | |
| 355 | + | |
| 356 | + poperror(); /* r */ | |
| 357 | + mntfree(r); | |
| 358 | + | |
| 359 | + poperror(); /* c */ | |
| 360 | + | |
| 361 | + if(bogus.flags&MCACHE) | |
| 362 | + c->flag |= CCACHE; | |
| 363 | + return c; | |
| 364 | +} | |
| 365 | + | |
| 366 | +Chan* | |
| 367 | +mntchan(void) | |
| 368 | +{ | |
| 369 | + Chan *c; | |
| 370 | + | |
| 371 | + c = devattach('M', 0); | |
| 372 | + lock(&mntalloc.lk); | |
| 373 | + c->dev = mntalloc.id++; | |
| 374 | + unlock(&mntalloc.lk); | |
| 375 | + | |
| 376 | + if(c->mchan) | |
| 377 | + panic("mntchan non-zero %p", c->mchan); | |
| 378 | + return c; | |
| 379 | +} | |
| 380 | + | |
| 381 | +static Walkqid* | |
| 382 | +mntwalk(Chan *c, Chan *nc, char **name, int nname) | |
| 383 | +{ | |
| 384 | + int i, alloc; | |
| 385 | + Mnt *m; | |
| 386 | + Mntrpc *r; | |
| 387 | + Walkqid *wq; | |
| 388 | + | |
| 389 | + if(nc != nil) | |
| 390 | + print("mntwalk: nc != nil\n"); | |
| 391 | + if(nname > MAXWELEM) | |
| 392 | + error("devmnt: too many name elements"); | |
| 393 | + alloc = 0; | |
| 394 | + wq = smalloc(sizeof(Walkqid)+(nname-1)*sizeof(Qid)); | |
| 395 | + if(waserror()){ | |
| 396 | + if(alloc && wq->clone!=nil) | |
| 397 | + cclose(wq->clone); | |
| 398 | + free(wq); | |
| 399 | + return nil; | |
| 400 | + } | |
| 401 | + | |
| 402 | + alloc = 0; | |
| 403 | + m = mntchk(c); | |
| 404 | + r = mntralloc(c, m->msize); | |
| 405 | + if(nc == nil){ | |
| 406 | + nc = devclone(c); | |
| 407 | + /* | |
| 408 | + * Until the other side accepts this fid, we can't mntclose it. | |
| 409 | + * Therefore set type to 0 for now; rootclose is known to be safe. | |
| 410 | + */ | |
| 411 | + nc->type = 0; | |
| 412 | + alloc = 1; | |
| 413 | + } | |
| 414 | + wq->clone = nc; | |
| 415 | + | |
| 416 | + if(waserror()) { | |
| 417 | + mntfree(r); | |
| 418 | + nexterror(); | |
| 419 | + } | |
| 420 | + r->request.type = Twalk; | |
| 421 | + r->request.fid = c->fid; | |
| 422 | + r->request.newfid = nc->fid; | |
| 423 | + r->request.nwname = nname; | |
| 424 | + memmove(r->request.wname, name, nname*sizeof(char*)); | |
| 425 | + | |
| 426 | + mountrpc(m, r); | |
| 427 | + | |
| 428 | + if(r->reply.nwqid > nname) | |
| 429 | + error("too many QIDs returned by walk"); | |
| 430 | + if(r->reply.nwqid < nname){ | |
| 431 | + if(alloc) | |
| 432 | + cclose(nc); | |
| 433 | + wq->clone = nil; | |
| 434 | + if(r->reply.nwqid == 0){ | |
| 435 | + free(wq); | |
| 436 | + wq = nil; | |
| 437 | + goto Return; | |
| 438 | + } | |
| 439 | + } | |
| 440 | + | |
| 441 | + /* move new fid onto mnt device and update its qid */ | |
| 442 | + if(wq->clone != nil){ | |
| 443 | + if(wq->clone != c){ | |
| 444 | + wq->clone->type = c->type; | |
| 445 | + wq->clone->mchan = c->mchan; | |
| 446 | + incref(&c->mchan->ref); | |
| 447 | + } | |
| 448 | + if(r->reply.nwqid > 0) | |
| 449 | + wq->clone->qid = r->reply.wqid[r->reply.nwqid-1]; | |
| 450 | + } | |
| 451 | + wq->nqid = r->reply.nwqid; | |
| 452 | + for(i=0; i<wq->nqid; i++) | |
| 453 | + wq->qid[i] = r->reply.wqid[i]; | |
| 454 | + | |
| 455 | + Return: | |
| 456 | + poperror(); | |
| 457 | + mntfree(r); | |
| 458 | + poperror(); | |
| 459 | + return wq; | |
| 460 | +} | |
| 461 | + | |
| 462 | +static int | |
| 463 | +mntstat(Chan *c, uchar *dp, int n) | |
| 464 | +{ | |
| 465 | + Mnt *m; | |
| 466 | + Mntrpc *r; | |
| 467 | + | |
| 468 | + if(n < BIT16SZ) | |
| 469 | + error(Eshortstat); | |
| 470 | + m = mntchk(c); | |
| 471 | + r = mntralloc(c, m->msize); | |
| 472 | + if(waserror()) { | |
| 473 | + mntfree(r); | |
| 474 | + nexterror(); | |
| 475 | + } | |
| 476 | + r->request.type = Tstat; | |
| 477 | + r->request.fid = c->fid; | |
| 478 | + mountrpc(m, r); | |
| 479 | + | |
| 480 | + if(r->reply.nstat >= 1<<(8*BIT16SZ)) | |
| 481 | + error("returned stat buffer count too large"); | |
| 482 | + | |
| 483 | + if(r->reply.nstat > n){ | |
| 484 | + /* | |
| 485 | + * 12/31/2002 RSC | |
| 486 | + * | |
| 487 | + * This should be nstat-2, which is the first two | |
| 488 | + * bytes of the stat buffer. But dirstat and dirfstat | |
| 489 | + * depended on getting the full nstat (they didn't | |
| 490 | + * add BIT16SZ themselves). I fixed dirstat and dirfstat | |
| 491 | + * but am leaving this unchanged for now. After a | |
| 492 | + * few months, once enough of the relevant binaries | |
| 493 | + * have been recompiled for other reasons, we can | |
| 494 | + * change this to nstat-2. Devstat gets this right | |
| 495 | + * (via convD2M). | |
| 496 | + */ | |
| 497 | + /* doesn't fit; just patch the count and return */ | |
| 498 | + PBIT16((uchar*)dp, r->reply.nstat); | |
| 499 | + n = BIT16SZ; | |
| 500 | + }else{ | |
| 501 | + n = r->reply.nstat; | |
| 502 | + memmove(dp, r->reply.stat, n); | |
| 503 | + validstat(dp, n); | |
| 504 | + mntdirfix(dp, c); | |
| 505 | + } | |
| 506 | + poperror(); | |
| 507 | + mntfree(r); | |
| 508 | + return n; | |
| 509 | +} | |
| 510 | + | |
| 511 | +static Chan* | |
| 512 | +mntopencreate(int type, Chan *c, char *name, int omode, ulong perm) | |
| 513 | +{ | |
| 514 | + Mnt *m; | |
| 515 | + Mntrpc *r; | |
| 516 | + | |
| 517 | + m = mntchk(c); | |
| 518 | + r = mntralloc(c, m->msize); | |
| 519 | + if(waserror()) { | |
| 520 | + mntfree(r); | |
| 521 | + nexterror(); | |
| 522 | + } | |
| 523 | + r->request.type = type; | |
| 524 | + r->request.fid = c->fid; | |
| 525 | + r->request.mode = omode; | |
| 526 | + if(type == Tcreate){ | |
| 527 | + r->request.perm = perm; | |
| 528 | + r->request.name = name; | |
| 529 | + } | |
| 530 | + mountrpc(m, r); | |
| 531 | + | |
| 532 | + c->qid = r->reply.qid; | |
| 533 | + c->offset = 0; | |
| 534 | + c->mode = openmode(omode); | |
| 535 | + c->iounit = r->reply.iounit; | |
| 536 | + if(c->iounit == 0 || c->iounit > m->msize-IOHDRSZ) | |
| 537 | + c->iounit = m->msize-IOHDRSZ; | |
| 538 | + c->flag |= COPEN; | |
| 539 | + poperror(); | |
| 540 | + mntfree(r); | |
| 541 | + | |
| 542 | + if(c->flag & CCACHE) | |
| 543 | + copen(c); | |
| 544 | + | |
| 545 | + return c; | |
| 546 | +} | |
| 547 | + | |
| 548 | +static Chan* | |
| 549 | +mntopen(Chan *c, int omode) | |
| 550 | +{ | |
| 551 | + return mntopencreate(Topen, c, nil, omode, 0); | |
| 552 | +} | |
| 553 | + | |
| 554 | +static void | |
| 555 | +mntcreate(Chan *c, char *name, int omode, ulong perm) | |
| 556 | +{ | |
| 557 | + mntopencreate(Tcreate, c, name, omode, perm); | |
| 558 | +} | |
| 559 | + | |
| 560 | +static void | |
| 561 | +mntclunk(Chan *c, int t) | |
| 562 | +{ | |
| 563 | + Mnt *m; | |
| 564 | + Mntrpc *r; | |
| 565 | + | |
| 566 | + m = mntchk(c); | |
| 567 | + r = mntralloc(c, m->msize); | |
| 568 | + if(waserror()){ | |
| 569 | + mntfree(r); | |
| 570 | + nexterror(); | |
| 571 | + } | |
| 572 | + | |
| 573 | + r->request.type = t; | |
| 574 | + r->request.fid = c->fid; | |
| 575 | + mountrpc(m, r); | |
| 576 | + mntfree(r); | |
| 577 | + poperror(); | |
| 578 | +} | |
| 579 | + | |
| 580 | +void | |
| 581 | +muxclose(Mnt *m) | |
| 582 | +{ | |
| 583 | + Mntrpc *q, *r; | |
| 584 | + | |
| 585 | + for(q = m->queue; q; q = r) { | |
| 586 | + r = q->list; | |
| 587 | + mntfree(q); | |
| 588 | + } | |
| 589 | + m->id = 0; | |
| 590 | + free(m->version); | |
| 591 | + m->version = nil; | |
| 592 | + mntpntfree(m); | |
| 593 | +} | |
| 594 | + | |
| 595 | +void | |
| 596 | +mntpntfree(Mnt *m) | |
| 597 | +{ | |
| 598 | + Mnt *f, **l; | |
| 599 | + Queue *q; | |
| 600 | + | |
| 601 | + lock(&mntalloc.lk); | |
| 602 | + l = &mntalloc.list; | |
| 603 | + for(f = *l; f; f = f->list) { | |
| 604 | + if(f == m) { | |
| 605 | + *l = m->list; | |
| 606 | + break; | |
| 607 | + } | |
| 608 | + l = &f->list; | |
| 609 | + } | |
| 610 | + m->list = mntalloc.mntfree; | |
| 611 | + mntalloc.mntfree = m; | |
| 612 | + q = m->q; | |
| 613 | + unlock(&mntalloc.lk); | |
| 614 | + | |
| 615 | + qfree(q); | |
| 616 | +} | |
| 617 | + | |
| 618 | +static void | |
| 619 | +mntclose(Chan *c) | |
| 620 | +{ | |
| 621 | + mntclunk(c, Tclunk); | |
| 622 | +} | |
| 623 | + | |
| 624 | +static void | |
| 625 | +mntremove(Chan *c) | |
| 626 | +{ | |
| 627 | + mntclunk(c, Tremove); | |
| 628 | +} | |
| 629 | + | |
| 630 | +static int | |
| 631 | +mntwstat(Chan *c, uchar *dp, int n) | |
| 632 | +{ | |
| 633 | + Mnt *m; | |
| 634 | + Mntrpc *r; | |
| 635 | + | |
| 636 | + m = mntchk(c); | |
| 637 | + r = mntralloc(c, m->msize); | |
| 638 | + if(waserror()) { | |
| 639 | + mntfree(r); | |
| 640 | + nexterror(); | |
| 641 | + } | |
| 642 | + r->request.type = Twstat; | |
| 643 | + r->request.fid = c->fid; | |
| 644 | + r->request.nstat = n; | |
| 645 | + r->request.stat = dp; | |
| 646 | + mountrpc(m, r); | |
| 647 | + poperror(); | |
| 648 | + mntfree(r); | |
| 649 | + return n; | |
| 650 | +} | |
| 651 | + | |
| 652 | +static long | |
| 653 | +mntread(Chan *c, void *buf, long n, vlong off) | |
| 654 | +{ | |
| 655 | + uchar *p, *e; | |
| 656 | + int nc, cache, isdir, dirlen; | |
| 657 | + | |
| 658 | + isdir = 0; | |
| 659 | + cache = c->flag & CCACHE; | |
| 660 | + if(c->qid.type & QTDIR) { | |
| 661 | + cache = 0; | |
| 662 | + isdir = 1; | |
| 663 | + } | |
| 664 | + | |
| 665 | + p = buf; | |
| 666 | + if(cache) { | |
| 667 | + nc = cread(c, buf, n, off); | |
| 668 | + if(nc > 0) { | |
| 669 | + n -= nc; | |
| 670 | + if(n == 0) | |
| 671 | + return nc; | |
| 672 | + p += nc; | |
| 673 | + off += nc; | |
| 674 | + } | |
| 675 | + n = mntrdwr(Tread, c, p, n, off); | |
| 676 | + cupdate(c, p, n, off); | |
| 677 | + return n + nc; | |
| 678 | + } | |
| 679 | + | |
| 680 | + n = mntrdwr(Tread, c, buf, n, off); | |
| 681 | + if(isdir) { | |
| 682 | + for(e = &p[n]; p+BIT16SZ < e; p += dirlen){ | |
| 683 | + dirlen = BIT16SZ+GBIT16(p); | |
| 684 | + if(p+dirlen > e) | |
| 685 | + break; | |
| 686 | + validstat(p, dirlen); | |
| 687 | + mntdirfix(p, c); | |
| 688 | + } | |
| 689 | + if(p != e) | |
| 690 | + error(Esbadstat); | |
| 691 | + } | |
| 692 | + return n; | |
| 693 | +} | |
| 694 | + | |
| 695 | +static long | |
| 696 | +mntwrite(Chan *c, void *buf, long n, vlong off) | |
| 697 | +{ | |
| 698 | + return mntrdwr(Twrite, c, buf, n, off); | |
| 699 | +} | |
| 700 | + | |
| 701 | +long | |
| 702 | +mntrdwr(int type, Chan *c, void *buf, long n, vlong off) | |
| 703 | +{ | |
| 704 | + Mnt *m; | |
| 705 | + Mntrpc *r; | |
| 706 | + char *uba; | |
| 707 | + int cache; | |
| 708 | + ulong cnt, nr, nreq; | |
| 709 | + | |
| 710 | + m = mntchk(c); | |
| 711 | + uba = buf; | |
| 712 | + cnt = 0; | |
| 713 | + cache = c->flag & CCACHE; | |
| 714 | + if(c->qid.type & QTDIR) | |
| 715 | + cache = 0; | |
| 716 | + for(;;) { | |
| 717 | + r = mntralloc(c, m->msize); | |
| 718 | + if(waserror()) { | |
| 719 | + mntfree(r); | |
| 720 | + nexterror(); | |
| 721 | + } | |
| 722 | + r->request.type = type; | |
| 723 | + r->request.fid = c->fid; | |
| 724 | + r->request.offset = off; | |
| 725 | + r->request.data = uba; | |
| 726 | + nr = n; | |
| 727 | + if(nr > m->msize-IOHDRSZ) | |
| 728 | + nr = m->msize-IOHDRSZ; | |
| 729 | + r->request.count = nr; | |
| 730 | + mountrpc(m, r); | |
| 731 | + nreq = r->request.count; | |
| 732 | + nr = r->reply.count; | |
| 733 | + if(nr > nreq) | |
| 734 | + nr = nreq; | |
| 735 | + | |
| 736 | + if(type == Tread) | |
| 737 | + r->b = bl2mem((uchar*)uba, r->b, nr); | |
| 738 | + else if(cache) | |
| 739 | + cwrite(c, (uchar*)uba, nr, off); | |
| 740 | + | |
| 741 | + poperror(); | |
| 742 | + mntfree(r); | |
| 743 | + off += nr; | |
| 744 | + uba += nr; | |
| 745 | + cnt += nr; | |
| 746 | + n -= nr; | |
| 747 | + if(nr != nreq || n == 0) | |
| 748 | + break; | |
| 749 | + } | |
| 750 | + return cnt; | |
| 751 | +} | |
| 752 | + | |
| 753 | +void | |
| 754 | +mountrpc(Mnt *m, Mntrpc *r) | |
| 755 | +{ | |
| 756 | + char *sn, *cn; | |
| 757 | + int t; | |
| 758 | + | |
| 759 | + r->reply.tag = 0; | |
| 760 | + r->reply.type = Tmax; /* can't ever be a valid message type */ | |
| 761 | + | |
| 762 | + mountio(m, r); | |
| 763 | + | |
| 764 | + t = r->reply.type; | |
| 765 | + switch(t) { | |
| 766 | + case Rerror: | |
| 767 | + error(r->reply.ename); | |
| 768 | + case Rflush: | |
| 769 | + error(Eintr); | |
| 770 | + default: | |
| 771 | + if(t == r->request.type+1) | |
| 772 | + break; | |
| 773 | + sn = "?"; | |
| 774 | + if(m->c->name != nil) | |
| 775 | + sn = m->c->name->s; | |
| 776 | + cn = "?"; | |
| 777 | + if(r->c != nil && r->c->name != nil) | |
| 778 | + cn = r->c->name->s; | |
| 779 | + print("mnt: proc %lud: mismatch from %s %s rep 0x%lux tag %d fid %d T%d R%d rp %d\n", | |
| 780 | + up->pid, sn, cn, | |
| 781 | + r, r->request.tag, r->request.fid, r->request.type, | |
| 782 | + r->reply.type, r->reply.tag); | |
| 783 | + error(Emountrpc); | |
| 784 | + } | |
| 785 | +} | |
| 786 | + | |
| 787 | +void | |
| 788 | +mountio(Mnt *m, Mntrpc *r) | |
| 789 | +{ | |
| 790 | + int n; | |
| 791 | + | |
| 792 | + while(waserror()) { | |
| 793 | + if(m->rip == up) | |
| 794 | + mntgate(m); | |
| 795 | + if(strcmp(up->errstr, Eintr) != 0){ | |
| 796 | + mntflushfree(m, r); | |
| 797 | + nexterror(); | |
| 798 | + } | |
| 799 | + r = mntflushalloc(r, m->msize); | |
| 800 | + } | |
| 801 | + | |
| 802 | + lock(&m->lk); | |
| 803 | + r->m = m; | |
| 804 | + r->list = m->queue; | |
| 805 | + m->queue = r; | |
| 806 | + unlock(&m->lk); | |
| 807 | + | |
| 808 | + /* Transmit a file system rpc */ | |
| 809 | + if(m->msize == 0) | |
| 810 | + panic("msize"); | |
| 811 | + n = convS2M(&r->request, r->rpc, m->msize); | |
| 812 | + if(n < 0) | |
| 813 | + panic("bad message type in mountio"); | |
| 814 | + if(devtab[m->c->type]->write(m->c, r->rpc, n, 0) != n) | |
| 815 | + error(Emountrpc); | |
| 816 | + r->stime = fastticks(nil); | |
| 817 | + r->reqlen = n; | |
| 818 | + | |
| 819 | + /* Gate readers onto the mount point one at a time */ | |
| 820 | + for(;;) { | |
| 821 | + lock(&m->lk); | |
| 822 | + if(m->rip == 0) | |
| 823 | + break; | |
| 824 | + unlock(&m->lk); | |
| 825 | + sleep(&r->r, rpcattn, r); | |
| 826 | + if(r->done){ | |
| 827 | + poperror(); | |
| 828 | + mntflushfree(m, r); | |
| 829 | + return; | |
| 830 | + } | |
| 831 | + } | |
| 832 | + m->rip = up; | |
| 833 | + unlock(&m->lk); | |
| 834 | + while(r->done == 0) { | |
| 835 | + if(mntrpcread(m, r) < 0) | |
| 836 | + error(Emountrpc); | |
| 837 | + mountmux(m, r); | |
| 838 | + } | |
| 839 | + mntgate(m); | |
| 840 | + poperror(); | |
| 841 | + mntflushfree(m, r); | |
| 842 | +} | |
| 843 | + | |
| 844 | +static int | |
| 845 | +doread(Mnt *m, int len) | |
| 846 | +{ | |
| 847 | + Block *b; | |
| 848 | + | |
| 849 | + while(qlen(m->q) < len){ | |
| 850 | + b = devtab[m->c->type]->bread(m->c, m->msize, 0); | |
| 851 | + if(b == nil) | |
| 852 | + return -1; | |
| 853 | + if(BLEN(b) == 0){ | |
| 854 | + freeblist(b); | |
| 855 | + return -1; | |
| 856 | + } | |
| 857 | + qaddlist(m->q, b); | |
| 858 | + } | |
| 859 | + return 0; | |
| 860 | +} | |
| 861 | + | |
| 862 | +int | |
| 863 | +mntrpcread(Mnt *m, Mntrpc *r) | |
| 864 | +{ | |
| 865 | + int i, t, len, hlen; | |
| 866 | + Block *b, **l, *nb; | |
| 867 | + | |
| 868 | + r->reply.type = 0; | |
| 869 | + r->reply.tag = 0; | |
| 870 | + | |
| 871 | + /* read at least length, type, and tag and pullup to a single block */ | |
| 872 | + if(doread(m, BIT32SZ+BIT8SZ+BIT16SZ) < 0) | |
| 873 | + return -1; | |
| 874 | + nb = pullupqueue(m->q, BIT32SZ+BIT8SZ+BIT16SZ); | |
| 875 | + | |
| 876 | + /* read in the rest of the message, avoid rediculous (for now) message sizes */ | |
| 877 | + len = GBIT32(nb->rp); | |
| 878 | + if(len > m->msize){ | |
| 879 | + qdiscard(m->q, qlen(m->q)); | |
| 880 | + return -1; | |
| 881 | + } | |
| 882 | + if(doread(m, len) < 0) | |
| 883 | + return -1; | |
| 884 | + | |
| 885 | + /* pullup the header (i.e. everything except data) */ | |
| 886 | + t = nb->rp[BIT32SZ]; | |
| 887 | + switch(t){ | |
| 888 | + case Rread: | |
| 889 | + hlen = BIT32SZ+BIT8SZ+BIT16SZ+BIT32SZ; | |
| 890 | + break; | |
| 891 | + default: | |
| 892 | + hlen = len; | |
| 893 | + break; | |
| 894 | + } | |
| 895 | + nb = pullupqueue(m->q, hlen); | |
| 896 | + | |
| 897 | + if(convM2S(nb->rp, len, &r->reply) <= 0){ | |
| 898 | + /* bad message, dump it */ | |
| 899 | + print("mntrpcread: convM2S failed\n"); | |
| 900 | + qdiscard(m->q, len); | |
| 901 | + return -1; | |
| 902 | + } | |
| 903 | + | |
| 904 | + /* hang the data off of the fcall struct */ | |
| 905 | + l = &r->b; | |
| 906 | + *l = nil; | |
| 907 | + do { | |
| 908 | + b = qremove(m->q); | |
| 909 | + if(hlen > 0){ | |
| 910 | + b->rp += hlen; | |
| 911 | + len -= hlen; | |
| 912 | + hlen = 0; | |
| 913 | + } | |
| 914 | + i = BLEN(b); | |
| 915 | + if(i <= len){ | |
| 916 | + len -= i; | |
| 917 | + *l = b; | |
| 918 | + l = &(b->next); | |
| 919 | + } else { | |
| 920 | + /* split block and put unused bit back */ | |
| 921 | + nb = allocb(i-len); | |
| 922 | + memmove(nb->wp, b->rp+len, i-len); | |
| 923 | + b->wp = b->rp+len; | |
| 924 | + nb->wp += i-len; | |
| 925 | + qputback(m->q, nb); | |
| 926 | + *l = b; | |
| 927 | + return 0; | |
| 928 | + } | |
| 929 | + }while(len > 0); | |
| 930 | + | |
| 931 | + return 0; | |
| 932 | +} | |
| 933 | + | |
| 934 | +void | |
| 935 | +mntgate(Mnt *m) | |
| 936 | +{ | |
| 937 | + Mntrpc *q; | |
| 938 | + | |
| 939 | + lock(&m->lk); | |
| 940 | + m->rip = 0; | |
| 941 | + for(q = m->queue; q; q = q->list) { | |
| 942 | + if(q->done == 0) | |
| 943 | + if(wakeup(&q->r)) | |
| 944 | + break; | |
| 945 | + } | |
| 946 | + unlock(&m->lk); | |
| 947 | +} | |
| 948 | + | |
| 949 | +void | |
| 950 | +mountmux(Mnt *m, Mntrpc *r) | |
| 951 | +{ | |
| 952 | + Mntrpc **l, *q; | |
| 953 | + | |
| 954 | + lock(&m->lk); | |
| 955 | + l = &m->queue; | |
| 956 | + for(q = *l; q; q = q->list) { | |
| 957 | + /* look for a reply to a message */ | |
| 958 | + if(q->request.tag == r->reply.tag) { | |
| 959 | + *l = q->list; | |
| 960 | + if(q != r) { | |
| 961 | + /* | |
| 962 | + * Completed someone else. | |
| 963 | + * Trade pointers to receive buffer. | |
| 964 | + */ | |
| 965 | + q->reply = r->reply; | |
| 966 | + q->b = r->b; | |
| 967 | + r->b = nil; | |
| 968 | + } | |
| 969 | + q->done = 1; | |
| 970 | + unlock(&m->lk); | |
| 971 | + if(mntstats != nil) | |
| 972 | + (*mntstats)(q->request.type, | |
| 973 | + m->c, q->stime, | |
| 974 | + q->reqlen + r->replen); | |
| 975 | + if(q != r) | |
| 976 | + wakeup(&q->r); | |
| 977 | + return; | |
| 978 | + } | |
| 979 | + l = &q->list; | |
| 980 | + } | |
| 981 | + unlock(&m->lk); | |
| 982 | + print("unexpected reply tag %ud; type %d\n", r->reply.tag, r->reply.type); | |
| 983 | +} | |
| 984 | + | |
| 985 | +/* | |
| 986 | + * Create a new flush request and chain the previous | |
| 987 | + * requests from it | |
| 988 | + */ | |
| 989 | +Mntrpc* | |
| 990 | +mntflushalloc(Mntrpc *r, ulong iounit) | |
| 991 | +{ | |
| 992 | + Mntrpc *fr; | |
| 993 | + | |
| 994 | + fr = mntralloc(0, iounit); | |
| 995 | + | |
| 996 | + fr->request.type = Tflush; | |
| 997 | + if(r->request.type == Tflush) | |
| 998 | + fr->request.oldtag = r->request.oldtag; | |
| 999 | + else | |
| 1000 | + fr->request.oldtag = r->request.tag; | |
| 1001 | + fr->flushed = r; | |
| 1002 | + | |
| 1003 | + return fr; | |
| 1004 | +} | |
| 1005 | + | |
| 1006 | +/* | |
| 1007 | + * Free a chain of flushes. Remove each unanswered | |
| 1008 | + * flush and the original message from the unanswered | |
| 1009 | + * request queue. Mark the original message as done | |
| 1010 | + * and if it hasn't been answered set the reply to to | |
| 1011 | + * Rflush. | |
| 1012 | + */ | |
| 1013 | +void | |
| 1014 | +mntflushfree(Mnt *m, Mntrpc *r) | |
| 1015 | +{ | |
| 1016 | + Mntrpc *fr; | |
| 1017 | + | |
| 1018 | + while(r){ | |
| 1019 | + fr = r->flushed; | |
| 1020 | + if(!r->done){ | |
| 1021 | + r->reply.type = Rflush; | |
| 1022 | + mntqrm(m, r); | |
| 1023 | + } | |
| 1024 | + if(fr) | |
| 1025 | + mntfree(r); | |
| 1026 | + r = fr; | |
| 1027 | + } | |
| 1028 | +} | |
| 1029 | + | |
| 1030 | +int | |
| 1031 | +alloctag(void) | |
| 1032 | +{ | |
| 1033 | + int i, j; | |
| 1034 | + ulong v; | |
| 1035 | + | |
| 1036 | + for(i = 0; i < NMASK; i++){ | |
| 1037 | + v = mntalloc.tagmask[i]; | |
| 1038 | + if(v == ~0UL) | |
| 1039 | + continue; | |
| 1040 | + for(j = 0; j < 1<<TAGSHIFT; j++) | |
| 1041 | + if((v & (1<<j)) == 0){ | |
| 1042 | + mntalloc.tagmask[i] |= 1<<j; | |
| 1043 | + return (i<<TAGSHIFT) + j; | |
| 1044 | + } | |
| 1045 | + } | |
| 1046 | + panic("no friggin tags left"); | |
| 1047 | + return NOTAG; | |
| 1048 | +} | |
| 1049 | + | |
| 1050 | +void | |
| 1051 | +freetag(int t) | |
| 1052 | +{ | |
| 1053 | + mntalloc.tagmask[t>>TAGSHIFT] &= ~(1<<(t&TAGMASK)); | |
| 1054 | +} | |
| 1055 | + | |
| 1056 | +Mntrpc* | |
| 1057 | +mntralloc(Chan *c, ulong msize) | |
| 1058 | +{ | |
| 1059 | + Mntrpc *new; | |
| 1060 | + | |
| 1061 | + lock(&mntalloc.lk); | |
| 1062 | + new = mntalloc.rpcfree; | |
| 1063 | + if(new == nil){ | |
| 1064 | + new = malloc(sizeof(Mntrpc)); | |
| 1065 | + if(new == nil) { | |
| 1066 | + unlock(&mntalloc.lk); | |
| 1067 | + exhausted("mount rpc header"); | |
| 1068 | + } | |
| 1069 | + /* | |
| 1070 | + * The header is split from the data buffer as | |
| 1071 | + * mountmux may swap the buffer with another header. | |
| 1072 | + */ | |
| 1073 | + new->rpc = mallocz(msize, 0); | |
| 1074 | + if(new->rpc == nil){ | |
| 1075 | + free(new); | |
| 1076 | + unlock(&mntalloc.lk); | |
| 1077 | + exhausted("mount rpc buffer"); | |
| 1078 | + } | |
| 1079 | + new->rpclen = msize; | |
| 1080 | + new->request.tag = alloctag(); | |
| 1081 | + } | |
| 1082 | + else { | |
| 1083 | + mntalloc.rpcfree = new->list; | |
| 1084 | + mntalloc.nrpcfree--; | |
| 1085 | + if(new->rpclen < msize){ | |
| 1086 | + free(new->rpc); | |
| 1087 | + new->rpc = mallocz(msize, 0); | |
| 1088 | + if(new->rpc == nil){ | |
| 1089 | + free(new); | |
| 1090 | + mntalloc.nrpcused--; | |
| 1091 | + unlock(&mntalloc.lk); | |
| 1092 | + exhausted("mount rpc buffer"); | |
| 1093 | + } | |
| 1094 | + new->rpclen = msize; | |
| 1095 | + } | |
| 1096 | + } | |
| 1097 | + mntalloc.nrpcused++; | |
| 1098 | + unlock(&mntalloc.lk); | |
| 1099 | + new->c = c; | |
| 1100 | + new->done = 0; | |
| 1101 | + new->flushed = nil; | |
| 1102 | + new->b = nil; | |
| 1103 | + return new; | |
| 1104 | +} | |
| 1105 | + | |
| 1106 | +void | |
| 1107 | +mntfree(Mntrpc *r) | |
| 1108 | +{ | |
| 1109 | + if(r->b != nil) | |
| 1110 | + freeblist(r->b); | |
| 1111 | + lock(&mntalloc.lk); | |
| 1112 | + if(mntalloc.nrpcfree >= 10){ | |
| 1113 | + free(r->rpc); | |
| 1114 | + free(r); | |
| 1115 | + freetag(r->request.tag); | |
| 1116 | + } | |
| 1117 | + else{ | |
| 1118 | + r->list = mntalloc.rpcfree; | |
| 1119 | + mntalloc.rpcfree = r; | |
| 1120 | + mntalloc.nrpcfree++; | |
| 1121 | + } | |
| 1122 | + mntalloc.nrpcused--; | |
| 1123 | + unlock(&mntalloc.lk); | |
| 1124 | +} | |
| 1125 | + | |
| 1126 | +void | |
| 1127 | +mntqrm(Mnt *m, Mntrpc *r) | |
| 1128 | +{ | |
| 1129 | + Mntrpc **l, *f; | |
| 1130 | + | |
| 1131 | + lock(&m->lk); | |
| 1132 | + r->done = 1; | |
| 1133 | + | |
| 1134 | + l = &m->queue; | |
| 1135 | + for(f = *l; f; f = f->list) { | |
| 1136 | + if(f == r) { | |
| 1137 | + *l = r->list; | |
| 1138 | + break; | |
| 1139 | + } | |
| 1140 | + l = &f->list; | |
| 1141 | + } | |
| 1142 | + unlock(&m->lk); | |
| 1143 | +} | |
| 1144 | + | |
| 1145 | +Mnt* | |
| 1146 | +mntchk(Chan *c) | |
| 1147 | +{ | |
| 1148 | + Mnt *m; | |
| 1149 | + | |
| 1150 | + /* This routine is mostly vestiges of prior lives; now it's just sanity checking */ | |
| 1151 | + | |
| 1152 | + if(c->mchan == nil) | |
| 1153 | + panic("mntchk 1: nil mchan c %s\n", c2name(c)); | |
| 1154 | + | |
| 1155 | + m = c->mchan->mux; | |
| 1156 | + | |
| 1157 | + if(m == nil) | |
| 1158 | + print("mntchk 2: nil mux c %s c->mchan %s \n", c2name(c), c2name(c->mchan)); | |
| 1159 | + | |
| 1160 | + /* | |
| 1161 | + * Was it closed and reused (was error(Eshutdown); now, it can't happen) | |
| 1162 | + */ | |
| 1163 | + if(m->id == 0 || m->id >= c->dev) | |
| 1164 | + panic("mntchk 3: can't happen"); | |
| 1165 | + | |
| 1166 | + return m; | |
| 1167 | +} | |
| 1168 | + | |
| 1169 | +/* | |
| 1170 | + * Rewrite channel type and dev for in-flight data to | |
| 1171 | + * reflect local values. These entries are known to be | |
| 1172 | + * the first two in the Dir encoding after the count. | |
| 1173 | + */ | |
| 1174 | +void | |
| 1175 | +mntdirfix(uchar *dirbuf, Chan *c) | |
| 1176 | +{ | |
| 1177 | + uint r; | |
| 1178 | + | |
| 1179 | + r = devtab[c->type]->dc; | |
| 1180 | + dirbuf += BIT16SZ; /* skip count */ | |
| 1181 | + PBIT16(dirbuf, r); | |
| 1182 | + dirbuf += BIT16SZ; | |
| 1183 | + PBIT32(dirbuf, c->dev); | |
| 1184 | +} | |
| 1185 | + | |
| 1186 | +int | |
| 1187 | +rpcattn(void *v) | |
| 1188 | +{ | |
| 1189 | + Mntrpc *r; | |
| 1190 | + | |
| 1191 | + r = v; | |
| 1192 | + return r->done || r->m->rip == 0; | |
| 1193 | +} | |
| 1194 | + | |
| 1195 | +Dev mntdevtab = { | |
| 1196 | + 'M', | |
| 1197 | + "mnt", | |
| 1198 | + | |
| 1199 | + mntreset, | |
| 1200 | + devinit, | |
| 1201 | + devshutdown, | |
| 1202 | + mntattach, | |
| 1203 | + mntwalk, | |
| 1204 | + mntstat, | |
| 1205 | + mntopen, | |
| 1206 | + mntcreate, | |
| 1207 | + mntclose, | |
| 1208 | + mntread, | |
| 1209 | + devbread, | |
| 1210 | + mntwrite, | |
| 1211 | + devbwrite, | |
| 1212 | + mntremove, | |
| 1213 | + mntwstat, | |
| 1214 | +}; | |
| @@ -0,0 +1,237 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +#include "draw.h" | |
| 8 | +#include "memdraw.h" | |
| 9 | +#include "screen.h" | |
| 10 | + | |
| 11 | +int mousequeue; | |
| 12 | + | |
| 13 | +Mouseinfo mouse; | |
| 14 | +Cursorinfo cursor; | |
| 15 | + | |
| 16 | +static int mousechanged(void*); | |
| 17 | + | |
| 18 | +enum{ | |
| 19 | + Qdir, | |
| 20 | + Qcursor, | |
| 21 | + Qmouse | |
| 22 | +}; | |
| 23 | + | |
| 24 | +Dirtab mousedir[]={ | |
| 25 | + ".", {Qdir, 0, QTDIR}, 0, DMDIR|0555, | |
| 26 | + "cursor", {Qcursor}, 0, 0666, | |
| 27 | + "mouse", {Qmouse}, 0, 0666, | |
| 28 | +}; | |
| 29 | + | |
| 30 | +#define NMOUSE (sizeof(mousedir)/sizeof(Dirtab)) | |
| 31 | + | |
| 32 | +static Chan* | |
| 33 | +mouseattach(char *spec) | |
| 34 | +{ | |
| 35 | + return devattach('m', spec); | |
| 36 | +} | |
| 37 | + | |
| 38 | +static Walkqid* | |
| 39 | +mousewalk(Chan *c, Chan *nc, char **name, int nname) | |
| 40 | +{ | |
| 41 | + return devwalk(c, nc, name, nname, mousedir, NMOUSE, devgen); | |
| 42 | +} | |
| 43 | + | |
| 44 | +static int | |
| 45 | +mousestat(Chan *c, uchar *db, int n) | |
| 46 | +{ | |
| 47 | + return devstat(c, db, n, mousedir, NMOUSE, devgen); | |
| 48 | +} | |
| 49 | + | |
| 50 | +static Chan* | |
| 51 | +mouseopen(Chan *c, int omode) | |
| 52 | +{ | |
| 53 | + switch((long)c->qid.path){ | |
| 54 | + case Qdir: | |
| 55 | + if(omode != OREAD) | |
| 56 | + error(Eperm); | |
| 57 | + break; | |
| 58 | + case Qmouse: | |
| 59 | + lock(&mouse.lk); | |
| 60 | + if(mouse.open){ | |
| 61 | + unlock(&mouse.lk); | |
| 62 | + error(Einuse); | |
| 63 | + } | |
| 64 | + mouse.open = 1; | |
| 65 | + unlock(&mouse.lk); | |
| 66 | + break; | |
| 67 | + } | |
| 68 | + c->mode = openmode(omode); | |
| 69 | + c->flag |= COPEN; | |
| 70 | + c->offset = 0; | |
| 71 | + return c; | |
| 72 | +} | |
| 73 | + | |
| 74 | +void | |
| 75 | +mouseclose(Chan *c) | |
| 76 | +{ | |
| 77 | + if(!(c->flag&COPEN)) | |
| 78 | + return; | |
| 79 | + | |
| 80 | + switch((long)c->qid.path) { | |
| 81 | + case Qmouse: | |
| 82 | + lock(&mouse.lk); | |
| 83 | + mouse.open = 0; | |
| 84 | + unlock(&mouse.lk); | |
| 85 | + cursorarrow(); | |
| 86 | + } | |
| 87 | +} | |
| 88 | + | |
| 89 | + | |
| 90 | +long | |
| 91 | +mouseread(Chan *c, void *va, long n, vlong offset) | |
| 92 | +{ | |
| 93 | + char buf[4*12+1]; | |
| 94 | + uchar *p; | |
| 95 | + int i, nn; | |
| 96 | + ulong msec; | |
| 97 | +/* static int map[8] = {0, 4, 2, 6, 1, 5, 3, 7 }; */ | |
| 98 | + | |
| 99 | + p = va; | |
| 100 | + switch((long)c->qid.path){ | |
| 101 | + case Qdir: | |
| 102 | + return devdirread(c, va, n, mousedir, NMOUSE, devgen); | |
| 103 | + | |
| 104 | + case Qcursor: | |
| 105 | + if(offset != 0) | |
| 106 | + return 0; | |
| 107 | + if(n < 2*4+2*2*16) | |
| 108 | + error(Eshort); | |
| 109 | + n = 2*4+2*2*16; | |
| 110 | + lock(&cursor.lk); | |
| 111 | + BPLONG(p+0, cursor.offset.x); | |
| 112 | + BPLONG(p+4, cursor.offset.y); | |
| 113 | + memmove(p+8, cursor.clr, 2*16); | |
| 114 | + memmove(p+40, cursor.set, 2*16); | |
| 115 | + unlock(&cursor.lk); | |
| 116 | + return n; | |
| 117 | + | |
| 118 | + case Qmouse: | |
| 119 | + while(mousechanged(0) == 0) | |
| 120 | + sleep(&mouse.r, mousechanged, 0); | |
| 121 | + | |
| 122 | + lock(&screen.lk); | |
| 123 | + if(screen.reshaped) { | |
| 124 | + screen.reshaped = 0; | |
| 125 | + sprint(buf, "t%11d %11d", 0, ticks()); | |
| 126 | + if(n > 1+2*12) | |
| 127 | + n = 1+2*12; | |
| 128 | + memmove(va, buf, n); | |
| 129 | + unlock(&screen.lk); | |
| 130 | + return n; | |
| 131 | + } | |
| 132 | + unlock(&screen.lk); | |
| 133 | + | |
| 134 | + lock(&mouse.lk); | |
| 135 | + i = mouse.ri; | |
| 136 | + nn = (mouse.wi + Mousequeue - i) % Mousequeue; | |
| 137 | + if(nn < 1) | |
| 138 | + panic("empty mouse queue"); | |
| 139 | + msec = ticks(); | |
| 140 | + while(nn > 1) { | |
| 141 | + if(mouse.queue[i].msec + Mousewindow > msec) | |
| 142 | + break; | |
| 143 | + i = (i+1)%Mousequeue; | |
| 144 | + nn--; | |
| 145 | + } | |
| 146 | + sprint(buf, "m%11d %11d %11d %11d", | |
| 147 | + mouse.queue[i].xy.x, | |
| 148 | + mouse.queue[i].xy.y, | |
| 149 | + mouse.queue[i].buttons, | |
| 150 | + mouse.queue[i].msec); | |
| 151 | + mouse.ri = (i+1)%Mousequeue; | |
| 152 | + unlock(&mouse.lk); | |
| 153 | + if(n > 1+4*12) | |
| 154 | + n = 1+4*12; | |
| 155 | + memmove(va, buf, n); | |
| 156 | + return n; | |
| 157 | + } | |
| 158 | + return 0; | |
| 159 | +} | |
| 160 | + | |
| 161 | +long | |
| 162 | +mousewrite(Chan *c, void *va, long n, vlong offset) | |
| 163 | +{ | |
| 164 | + char *p; | |
| 165 | + Point pt; | |
| 166 | + char buf[64]; | |
| 167 | + | |
| 168 | + USED(offset); | |
| 169 | + | |
| 170 | + p = va; | |
| 171 | + switch((long)c->qid.path){ | |
| 172 | + case Qdir: | |
| 173 | + error(Eisdir); | |
| 174 | + | |
| 175 | + case Qcursor: | |
| 176 | + if(n < 2*4+2*2*16){ | |
| 177 | + cursorarrow(); | |
| 178 | + }else{ | |
| 179 | + n = 2*4+2*2*16; | |
| 180 | + lock(&cursor.lk); | |
| 181 | + cursor.offset.x = BGLONG(p+0); | |
| 182 | + cursor.offset.y = BGLONG(p+4); | |
| 183 | + memmove(cursor.clr, p+8, 2*16); | |
| 184 | + memmove(cursor.set, p+40, 2*16); | |
| 185 | + unlock(&cursor.lk); | |
| 186 | + setcursor(); | |
| 187 | + } | |
| 188 | + return n; | |
| 189 | + | |
| 190 | + case Qmouse: | |
| 191 | + if(n > sizeof buf-1) | |
| 192 | + n = sizeof buf -1; | |
| 193 | + memmove(buf, va, n); | |
| 194 | + buf[n] = 0; | |
| 195 | + p = 0; | |
| 196 | + pt.x = strtoul(buf+1, &p, 0); | |
| 197 | + if(p == 0) | |
| 198 | + error(Eshort); | |
| 199 | + pt.y = strtoul(p, 0, 0); | |
| 200 | + if(ptinrect(pt, gscreen->r)) | |
| 201 | + mouseset(pt); | |
| 202 | + return n; | |
| 203 | + } | |
| 204 | + | |
| 205 | + error(Egreg); | |
| 206 | + return -1; | |
| 207 | +} | |
| 208 | + | |
| 209 | +int | |
| 210 | +mousechanged(void *a) | |
| 211 | +{ | |
| 212 | + USED(a); | |
| 213 | + | |
| 214 | + return mouse.ri != mouse.wi || screen.reshaped; | |
| 215 | +} | |
| 216 | + | |
| 217 | +Dev mousedevtab = { | |
| 218 | + 'm', | |
| 219 | + "mouse", | |
| 220 | + | |
| 221 | + devreset, | |
| 222 | + devinit, | |
| 223 | + devshutdown, | |
| 224 | + mouseattach, | |
| 225 | + mousewalk, | |
| 226 | + mousestat, | |
| 227 | + mouseopen, | |
| 228 | + devcreate, | |
| 229 | + mouseclose, | |
| 230 | + mouseread, | |
| 231 | + devbread, | |
| 232 | + mousewrite, | |
| 233 | + devbwrite, | |
| 234 | + devremove, | |
| 235 | + devwstat, | |
| 236 | +}; | |
| 237 | + | |
| @@ -0,0 +1,704 @@ | ||
| 1 | +#include <windows.h> | |
| 2 | +#include <sys/types.h> | |
| 3 | +#include <sys/stat.h> | |
| 4 | +#include <fcntl.h> | |
| 5 | + | |
| 6 | +#ifndef NAME_MAX | |
| 7 | +# define NAME_MAX 256 | |
| 8 | +#endif | |
| 9 | +#include "u.h" | |
| 10 | +#include "lib.h" | |
| 11 | +#include "dat.h" | |
| 12 | +#include "fns.h" | |
| 13 | +#include "error.h" | |
| 14 | + | |
| 15 | +typedef struct DIR DIR; | |
| 16 | +typedef struct Ufsinfo Ufsinfo; | |
| 17 | + | |
| 18 | +enum | |
| 19 | +{ | |
| 20 | + NUID = 256, | |
| 21 | + NGID = 256, | |
| 22 | + MAXPATH = 1024, | |
| 23 | + MAXCOMP = 128 | |
| 24 | +}; | |
| 25 | + | |
| 26 | +struct DIR | |
| 27 | +{ | |
| 28 | + HANDLE handle; | |
| 29 | + char* path; | |
| 30 | + int index; | |
| 31 | + WIN32_FIND_DATA wfd; | |
| 32 | +}; | |
| 33 | + | |
| 34 | +struct Ufsinfo | |
| 35 | +{ | |
| 36 | + int mode; | |
| 37 | + int fd; | |
| 38 | + int uid; | |
| 39 | + int gid; | |
| 40 | + DIR* dir; | |
| 41 | + ulong offset; | |
| 42 | + QLock oq; | |
| 43 | + char nextname[NAME_MAX]; | |
| 44 | +}; | |
| 45 | + | |
| 46 | +DIR* opendir(char*); | |
| 47 | +int readdir(char*, DIR*); | |
| 48 | +void closedir(DIR*); | |
| 49 | +void rewinddir(DIR*); | |
| 50 | + | |
| 51 | +char *base = "c:/."; | |
| 52 | + | |
| 53 | +static Qid fsqid(char*, struct stat *); | |
| 54 | +static void fspath(Chan*, char*, char*); | |
| 55 | +// static void fsperm(Chan*, int); | |
| 56 | +static ulong fsdirread(Chan*, uchar*, int, ulong); | |
| 57 | +static int fsomode(int); | |
| 58 | +static int chown(char *path, int uid, int); | |
| 59 | +static int link(char *path, char *next); | |
| 60 | + | |
| 61 | +/* clumsy hack, but not worse than the Path stuff in the last one */ | |
| 62 | +static char* | |
| 63 | +uc2name(Chan *c) | |
| 64 | +{ | |
| 65 | + char *s; | |
| 66 | + | |
| 67 | + if(c->name == nil) | |
| 68 | + return "/"; | |
| 69 | + s = c2name(c); | |
| 70 | + if(s[0]=='#' && s[1]=='U') | |
| 71 | + return s+2; | |
| 72 | + return s; | |
| 73 | +} | |
| 74 | + | |
| 75 | +static char* | |
| 76 | +lastelem(Chan *c) | |
| 77 | +{ | |
| 78 | + char *s, *t; | |
| 79 | + | |
| 80 | + s = uc2name(c); | |
| 81 | + if((t = strrchr(s, '/')) == nil) | |
| 82 | + return s; | |
| 83 | + if(t[1] == 0) | |
| 84 | + return t; | |
| 85 | + return t+1; | |
| 86 | +} | |
| 87 | + | |
| 88 | +static Chan* | |
| 89 | +fsattach(void *spec) | |
| 90 | +{ | |
| 91 | + Chan *c; | |
| 92 | + struct stat stbuf; | |
| 93 | + static int devno; | |
| 94 | + Ufsinfo *uif; | |
| 95 | + | |
| 96 | + if(stat(base, &stbuf) < 0) | |
| 97 | + error(strerror(errno)); | |
| 98 | + | |
| 99 | + c = devattach('U', spec); | |
| 100 | + | |
| 101 | + uif = mallocz(sizeof(Ufsinfo), 1); | |
| 102 | + uif->gid = stbuf.st_gid; | |
| 103 | + uif->uid = stbuf.st_uid; | |
| 104 | + uif->mode = stbuf.st_mode; | |
| 105 | + | |
| 106 | + c->aux = uif; | |
| 107 | + c->dev = devno++; | |
| 108 | + c->qid.type = QTDIR; | |
| 109 | +/*print("fsattach %s\n", c2name(c));*/ | |
| 110 | + | |
| 111 | + return c; | |
| 112 | +} | |
| 113 | + | |
| 114 | +static Chan* | |
| 115 | +fsclone(Chan *c, Chan *nc) | |
| 116 | +{ | |
| 117 | + Ufsinfo *uif; | |
| 118 | + | |
| 119 | + uif = mallocz(sizeof(Ufsinfo), 1); | |
| 120 | + *uif = *(Ufsinfo*)c->aux; | |
| 121 | + nc->aux = uif; | |
| 122 | + | |
| 123 | + return nc; | |
| 124 | +} | |
| 125 | + | |
| 126 | +static int | |
| 127 | +fswalk1(Chan *c, char *name) | |
| 128 | +{ | |
| 129 | + struct stat stbuf; | |
| 130 | + char path[MAXPATH]; | |
| 131 | + Ufsinfo *uif; | |
| 132 | + | |
| 133 | + fspath(c, name, path); | |
| 134 | + | |
| 135 | + /* print("** fs walk '%s' -> %s\n", path, name); /**/ | |
| 136 | + | |
| 137 | + if(stat(path, &stbuf) < 0) | |
| 138 | + return 0; | |
| 139 | + | |
| 140 | + uif = c->aux; | |
| 141 | + | |
| 142 | + uif->gid = stbuf.st_gid; | |
| 143 | + uif->uid = stbuf.st_uid; | |
| 144 | + uif->mode = stbuf.st_mode; | |
| 145 | + | |
| 146 | + c->qid = fsqid(path, &stbuf); | |
| 147 | + | |
| 148 | + return 1; | |
| 149 | +} | |
| 150 | + | |
| 151 | +extern Cname* addelem(Cname*, char*); | |
| 152 | + | |
| 153 | +static Walkqid* | |
| 154 | +fswalk(Chan *c, Chan *nc, char **name, int nname) | |
| 155 | +{ | |
| 156 | + int i; | |
| 157 | + Cname *cname; | |
| 158 | + Walkqid *wq; | |
| 159 | + | |
| 160 | + if(nc != nil) | |
| 161 | + panic("fswalk: nc != nil"); | |
| 162 | + wq = smalloc(sizeof(Walkqid)+(nname-1)*sizeof(Qid)); | |
| 163 | + nc = devclone(c); | |
| 164 | + cname = c->name; | |
| 165 | + incref(&cname->ref); | |
| 166 | + | |
| 167 | + fsclone(c, nc); | |
| 168 | + wq->clone = nc; | |
| 169 | + for(i=0; i<nname; i++){ | |
| 170 | + nc->name = cname; | |
| 171 | + if(fswalk1(nc, name[i]) == 0) | |
| 172 | + break; | |
| 173 | + cname = addelem(cname, name[i]); | |
| 174 | + wq->qid[i] = nc->qid; | |
| 175 | + } | |
| 176 | + nc->name = nil; | |
| 177 | + cnameclose(cname); | |
| 178 | + if(i != nname){ | |
| 179 | + cclose(nc); | |
| 180 | + wq->clone = nil; | |
| 181 | + } | |
| 182 | + wq->nqid = i; | |
| 183 | + return wq; | |
| 184 | +} | |
| 185 | + | |
| 186 | +static int | |
| 187 | +fsstat(Chan *c, uchar *buf, int n) | |
| 188 | +{ | |
| 189 | + Dir d; | |
| 190 | + struct stat stbuf; | |
| 191 | + char path[MAXPATH]; | |
| 192 | + | |
| 193 | + if(n < BIT16SZ) | |
| 194 | + error(Eshortstat); | |
| 195 | + | |
| 196 | + fspath(c, 0, path); | |
| 197 | + if(stat(path, &stbuf) < 0) | |
| 198 | + error(strerror(errno)); | |
| 199 | + | |
| 200 | + d.name = lastelem(c); | |
| 201 | + d.uid = "unknown"; | |
| 202 | + d.gid = "unknown"; | |
| 203 | + d.muid = "unknown"; | |
| 204 | + d.qid = c->qid; | |
| 205 | + d.mode = (c->qid.type<<24)|(stbuf.st_mode&0777); | |
| 206 | + d.atime = stbuf.st_atime; | |
| 207 | + d.mtime = stbuf.st_mtime; | |
| 208 | + d.length = stbuf.st_size; | |
| 209 | + d.type = 'U'; | |
| 210 | + d.dev = c->dev; | |
| 211 | + return convD2M(&d, buf, n); | |
| 212 | +} | |
| 213 | + | |
| 214 | +static Chan* | |
| 215 | +fsopen(Chan *c, int mode) | |
| 216 | +{ | |
| 217 | + char path[MAXPATH]; | |
| 218 | + int m, isdir; | |
| 219 | + Ufsinfo *uif; | |
| 220 | + | |
| 221 | +/*print("fsopen %s\n", c2name(c));*/ | |
| 222 | + m = mode & (OTRUNC|3); | |
| 223 | + switch(m) { | |
| 224 | + case 0: | |
| 225 | + break; | |
| 226 | + case 1: | |
| 227 | + case 1|16: | |
| 228 | + break; | |
| 229 | + case 2: | |
| 230 | + case 0|16: | |
| 231 | + case 2|16: | |
| 232 | + break; | |
| 233 | + case 3: | |
| 234 | + break; | |
| 235 | + default: | |
| 236 | + error(Ebadarg); | |
| 237 | + } | |
| 238 | + | |
| 239 | + isdir = c->qid.type & QTDIR; | |
| 240 | + | |
| 241 | + if(isdir && mode != OREAD) | |
| 242 | + error(Eperm); | |
| 243 | + | |
| 244 | + m = fsomode(m & 3); | |
| 245 | + c->mode = openmode(mode); | |
| 246 | + | |
| 247 | + uif = c->aux; | |
| 248 | + | |
| 249 | + fspath(c, 0, path); | |
| 250 | + if(isdir) { | |
| 251 | + uif->dir = opendir(path); | |
| 252 | + if(uif->dir == 0) | |
| 253 | + error(strerror(errno)); | |
| 254 | + } | |
| 255 | + else { | |
| 256 | + if(mode & OTRUNC) | |
| 257 | + m |= O_TRUNC; | |
| 258 | + uif->fd = open(path, m|_O_BINARY, 0666); | |
| 259 | + | |
| 260 | + if(uif->fd < 0) | |
| 261 | + error(strerror(errno)); | |
| 262 | + } | |
| 263 | + uif->offset = 0; | |
| 264 | + | |
| 265 | + c->offset = 0; | |
| 266 | + c->flag |= COPEN; | |
| 267 | + return c; | |
| 268 | +} | |
| 269 | + | |
| 270 | +static void | |
| 271 | +fscreate(Chan *c, char *name, int mode, ulong perm) | |
| 272 | +{ | |
| 273 | + int fd, m; | |
| 274 | + char path[MAXPATH]; | |
| 275 | + struct stat stbuf; | |
| 276 | + Ufsinfo *uif; | |
| 277 | + | |
| 278 | + m = fsomode(mode&3); | |
| 279 | + | |
| 280 | + fspath(c, name, path); | |
| 281 | + | |
| 282 | + uif = c->aux; | |
| 283 | + | |
| 284 | + if(perm & DMDIR) { | |
| 285 | + if(m) | |
| 286 | + error(Eperm); | |
| 287 | + | |
| 288 | + if(mkdir(path) < 0) | |
| 289 | + error(strerror(errno)); | |
| 290 | + | |
| 291 | + fd = open(path, 0); | |
| 292 | + if(fd >= 0) { | |
| 293 | + chmod(path, perm & 0777); | |
| 294 | + chown(path, uif->uid, uif->uid); | |
| 295 | + } | |
| 296 | + close(fd); | |
| 297 | + | |
| 298 | + uif->dir = opendir(path); | |
| 299 | + if(uif->dir == 0) | |
| 300 | + error(strerror(errno)); | |
| 301 | + } | |
| 302 | + else { | |
| 303 | + fd = open(path, _O_WRONLY|_O_BINARY|_O_CREAT|_O_TRUNC, 0666); | |
| 304 | + if(fd >= 0) { | |
| 305 | + if(m != 1) { | |
| 306 | + close(fd); | |
| 307 | + fd = open(path, m|_O_BINARY); | |
| 308 | + } | |
| 309 | + chmod(path, perm & 0777); | |
| 310 | + chown(path, uif->uid, uif->gid); | |
| 311 | + } | |
| 312 | + if(fd < 0) | |
| 313 | + error(strerror(errno)); | |
| 314 | + uif->fd = fd; | |
| 315 | + } | |
| 316 | + | |
| 317 | + if(stat(path, &stbuf) < 0) | |
| 318 | + error(strerror(errno)); | |
| 319 | + c->qid = fsqid(path, &stbuf); | |
| 320 | + c->offset = 0; | |
| 321 | + c->flag |= COPEN; | |
| 322 | + c->mode = openmode(mode); | |
| 323 | +} | |
| 324 | + | |
| 325 | +static void | |
| 326 | +fsclose(Chan *c) | |
| 327 | +{ | |
| 328 | + Ufsinfo *uif; | |
| 329 | + | |
| 330 | + uif = c->aux; | |
| 331 | + | |
| 332 | + if(c->flag & COPEN) { | |
| 333 | + if(c->qid.type & QTDIR) | |
| 334 | + closedir(uif->dir); | |
| 335 | + else | |
| 336 | + close(uif->fd); | |
| 337 | + } | |
| 338 | + | |
| 339 | + free(uif); | |
| 340 | +} | |
| 341 | + | |
| 342 | +static long | |
| 343 | +fsread(Chan *c, void *va, long n, ulong offset) | |
| 344 | +{ | |
| 345 | + int fd, r; | |
| 346 | + Ufsinfo *uif; | |
| 347 | + | |
| 348 | +/*print("fsread %s\n", c2name(c));*/ | |
| 349 | + if(c->qid.type & QTDIR) | |
| 350 | + return fsdirread(c, va, n, offset); | |
| 351 | + | |
| 352 | + uif = c->aux; | |
| 353 | + qlock(&uif->oq); | |
| 354 | + if(waserror()) { | |
| 355 | + qunlock(&uif->oq); | |
| 356 | + nexterror(); | |
| 357 | + } | |
| 358 | + fd = uif->fd; | |
| 359 | + if(uif->offset != offset) { | |
| 360 | + r = lseek(fd, offset, 0); | |
| 361 | + if(r < 0) | |
| 362 | + error(strerror(errno)); | |
| 363 | + uif->offset = offset; | |
| 364 | + } | |
| 365 | + | |
| 366 | + n = read(fd, va, n); | |
| 367 | + if(n < 0) | |
| 368 | + error(strerror(errno)); | |
| 369 | + | |
| 370 | + uif->offset += n; | |
| 371 | + qunlock(&uif->oq); | |
| 372 | + poperror(); | |
| 373 | + | |
| 374 | + return n; | |
| 375 | +} | |
| 376 | + | |
| 377 | +static long | |
| 378 | +fswrite(Chan *c, void *va, long n, ulong offset) | |
| 379 | +{ | |
| 380 | + int fd, r; | |
| 381 | + Ufsinfo *uif; | |
| 382 | + | |
| 383 | + uif = c->aux; | |
| 384 | + | |
| 385 | + qlock(&uif->oq); | |
| 386 | + if(waserror()) { | |
| 387 | + qunlock(&uif->oq); | |
| 388 | + nexterror(); | |
| 389 | + } | |
| 390 | + fd = uif->fd; | |
| 391 | + if(uif->offset != offset) { | |
| 392 | + r = lseek(fd, offset, 0); | |
| 393 | + if(r < 0) | |
| 394 | + error(strerror(errno)); | |
| 395 | + uif->offset = offset; | |
| 396 | + } | |
| 397 | + | |
| 398 | + n = write(fd, va, n); | |
| 399 | + if(n < 0) | |
| 400 | + error(strerror(errno)); | |
| 401 | + | |
| 402 | + uif->offset += n; | |
| 403 | + qunlock(&uif->oq); | |
| 404 | + poperror(); | |
| 405 | + | |
| 406 | + return n; | |
| 407 | +} | |
| 408 | + | |
| 409 | +static void | |
| 410 | +fsremove(Chan *c) | |
| 411 | +{ | |
| 412 | + int n; | |
| 413 | + char path[MAXPATH]; | |
| 414 | + | |
| 415 | + fspath(c, 0, path); | |
| 416 | + if(c->qid.type & QTDIR) | |
| 417 | + n = rmdir(path); | |
| 418 | + else | |
| 419 | + n = remove(path); | |
| 420 | + if(n < 0) | |
| 421 | + error(strerror(errno)); | |
| 422 | +} | |
| 423 | + | |
| 424 | +static int | |
| 425 | +fswstat(Chan *c, uchar *buf, int n) | |
| 426 | +{ | |
| 427 | + Dir d; | |
| 428 | + struct stat stbuf; | |
| 429 | + char old[MAXPATH], new[MAXPATH]; | |
| 430 | + char strs[MAXPATH*3], *p; | |
| 431 | + Ufsinfo *uif; | |
| 432 | + | |
| 433 | + if (convM2D(buf, n, &d, strs) != n) | |
| 434 | + error(Ebadstat); | |
| 435 | + | |
| 436 | + fspath(c, 0, old); | |
| 437 | + if(stat(old, &stbuf) < 0) | |
| 438 | + error(strerror(errno)); | |
| 439 | + | |
| 440 | + uif = c->aux; | |
| 441 | + | |
| 442 | +// if(uif->uid != stbuf.st_uid) | |
| 443 | +// error(Eowner); | |
| 444 | + | |
| 445 | + if(d.name[0] && strcmp(d.name, lastelem(c)) != 0) { | |
| 446 | + fspath(c, 0, old); | |
| 447 | + strcpy(new, old); | |
| 448 | + p = strrchr(new, '/'); | |
| 449 | + strcpy(p+1, d.name); | |
| 450 | + if(rename(old, new) < 0) | |
| 451 | + error(strerror(errno)); | |
| 452 | + } | |
| 453 | + | |
| 454 | + fspath(c, 0, old); | |
| 455 | + if(~d.mode != 0 && (int)(d.mode&0777) != (int)(stbuf.st_mode&0777)) { | |
| 456 | + if(chmod(old, d.mode&0777) < 0) | |
| 457 | + error(strerror(errno)); | |
| 458 | + uif->mode &= ~0777; | |
| 459 | + uif->mode |= d.mode&0777; | |
| 460 | + } | |
| 461 | +/* | |
| 462 | + p = name2pass(gid, d.gid); | |
| 463 | + if(p == 0) | |
| 464 | + error(Eunknown); | |
| 465 | + | |
| 466 | + if(p->id != stbuf.st_gid) { | |
| 467 | + if(chown(old, stbuf.st_uid, p->id) < 0) | |
| 468 | + error(sys_errlist[errno]); | |
| 469 | + | |
| 470 | + uif->gid = p->id; | |
| 471 | + } | |
| 472 | +*/ | |
| 473 | + return n; | |
| 474 | +} | |
| 475 | + | |
| 476 | +static Qid | |
| 477 | +fsqid(char *p, struct stat *st) | |
| 478 | +{ | |
| 479 | + Qid q; | |
| 480 | + int dev; | |
| 481 | + ulong h; | |
| 482 | + static int nqdev; | |
| 483 | + static uchar *qdev; | |
| 484 | + | |
| 485 | + if(qdev == 0) | |
| 486 | + qdev = mallocz(65536U, 1); | |
| 487 | + | |
| 488 | + q.type = 0; | |
| 489 | + if((st->st_mode&S_IFMT) == S_IFDIR) | |
| 490 | + q.type = QTDIR; | |
| 491 | + | |
| 492 | + dev = st->st_dev & 0xFFFFUL; | |
| 493 | + if(qdev[dev] == 0) | |
| 494 | + qdev[dev] = ++nqdev; | |
| 495 | + | |
| 496 | + h = 0; | |
| 497 | + while(*p != '\0') | |
| 498 | + h += *p++ * 13; | |
| 499 | + | |
| 500 | + q.path = (vlong)qdev[dev]<<32; | |
| 501 | + q.path |= h; | |
| 502 | + q.vers = st->st_mtime; | |
| 503 | + | |
| 504 | + return q; | |
| 505 | +} | |
| 506 | + | |
| 507 | +static void | |
| 508 | +fspath(Chan *c, char *ext, char *path) | |
| 509 | +{ | |
| 510 | + strcpy(path, base); | |
| 511 | + strcat(path, "/"); | |
| 512 | + strcat(path, uc2name(c)); | |
| 513 | + if(ext) { | |
| 514 | + strcat(path, "/"); | |
| 515 | + strcat(path, ext); | |
| 516 | + } | |
| 517 | + cleanname(path); | |
| 518 | +} | |
| 519 | + | |
| 520 | +static int | |
| 521 | +isdots(char *name) | |
| 522 | +{ | |
| 523 | + if(name[0] != '.') | |
| 524 | + return 0; | |
| 525 | + if(name[1] == '\0') | |
| 526 | + return 1; | |
| 527 | + if(name[1] != '.') | |
| 528 | + return 0; | |
| 529 | + if(name[2] == '\0') | |
| 530 | + return 1; | |
| 531 | + return 0; | |
| 532 | +} | |
| 533 | + | |
| 534 | +static int | |
| 535 | +p9readdir(char *name, Ufsinfo *uif) | |
| 536 | +{ | |
| 537 | + if(uif->nextname[0]){ | |
| 538 | + strcpy(name, uif->nextname); | |
| 539 | + uif->nextname[0] = 0; | |
| 540 | + return 1; | |
| 541 | + } | |
| 542 | + | |
| 543 | + return readdir(name, uif->dir); | |
| 544 | +} | |
| 545 | + | |
| 546 | +static ulong | |
| 547 | +fsdirread(Chan *c, uchar *va, int count, ulong offset) | |
| 548 | +{ | |
| 549 | + int i; | |
| 550 | + Dir d; | |
| 551 | + long n; | |
| 552 | + char de[NAME_MAX]; | |
| 553 | + struct stat stbuf; | |
| 554 | + char path[MAXPATH], dirpath[MAXPATH]; | |
| 555 | + Ufsinfo *uif; | |
| 556 | + | |
| 557 | +/*print("fsdirread %s\n", c2name(c));*/ | |
| 558 | + i = 0; | |
| 559 | + uif = c->aux; | |
| 560 | + | |
| 561 | + errno = 0; | |
| 562 | + if(uif->offset != offset) { | |
| 563 | + if(offset != 0) | |
| 564 | + error("bad offset in fsdirread"); | |
| 565 | + uif->offset = offset; /* sync offset */ | |
| 566 | + uif->nextname[0] = 0; | |
| 567 | + rewinddir(uif->dir); | |
| 568 | + } | |
| 569 | + | |
| 570 | + fspath(c, 0, dirpath); | |
| 571 | + | |
| 572 | + while(i+BIT16SZ < count) { | |
| 573 | + if(!p9readdir(de, uif)) | |
| 574 | + break; | |
| 575 | + | |
| 576 | + if(de[0]==0 || isdots(de)) | |
| 577 | + continue; | |
| 578 | + | |
| 579 | + d.name = de; | |
| 580 | + sprint(path, "%s/%s", dirpath, de); | |
| 581 | + memset(&stbuf, 0, sizeof stbuf); | |
| 582 | + | |
| 583 | + if(stat(path, &stbuf) < 0) { | |
| 584 | + print("dir: bad path %s\n", path); | |
| 585 | + /* but continue... probably a bad symlink */ | |
| 586 | + } | |
| 587 | + | |
| 588 | + d.uid = "unknown"; | |
| 589 | + d.gid = "unknown"; | |
| 590 | + d.muid = "unknown"; | |
| 591 | + d.qid = fsqid(path, &stbuf); | |
| 592 | + d.mode = (d.qid.type<<24)|(stbuf.st_mode&0777); | |
| 593 | + d.atime = stbuf.st_atime; | |
| 594 | + d.mtime = stbuf.st_mtime; | |
| 595 | + d.length = stbuf.st_size; | |
| 596 | + d.type = 'U'; | |
| 597 | + d.dev = c->dev; | |
| 598 | + n = convD2M(&d, (char*)va+i, count-i); | |
| 599 | + if(n == BIT16SZ){ | |
| 600 | + strcpy(uif->nextname, de); | |
| 601 | + break; | |
| 602 | + } | |
| 603 | + i += n; | |
| 604 | + } | |
| 605 | +/*print("got %d\n", i);*/ | |
| 606 | + uif->offset += i; | |
| 607 | + return i; | |
| 608 | +} | |
| 609 | + | |
| 610 | +static int | |
| 611 | +fsomode(int m) | |
| 612 | +{ | |
| 613 | + switch(m) { | |
| 614 | + case 0: /* OREAD */ | |
| 615 | + case 3: /* OEXEC */ | |
| 616 | + return 0; | |
| 617 | + case 1: /* OWRITE */ | |
| 618 | + return 1; | |
| 619 | + case 2: /* ORDWR */ | |
| 620 | + return 2; | |
| 621 | + } | |
| 622 | + error(Ebadarg); | |
| 623 | + return 0; | |
| 624 | +} | |
| 625 | +void | |
| 626 | +closedir(DIR *d) | |
| 627 | +{ | |
| 628 | + FindClose(d->handle); | |
| 629 | + free(d->path); | |
| 630 | +} | |
| 631 | + | |
| 632 | +int | |
| 633 | +readdir(char *name, DIR *d) | |
| 634 | +{ | |
| 635 | + if(d->index != 0) { | |
| 636 | + if(FindNextFile(d->handle, &d->wfd) == FALSE) | |
| 637 | + return 0; | |
| 638 | + } | |
| 639 | + strcpy(name, d->wfd.cFileName); | |
| 640 | + d->index++; | |
| 641 | + | |
| 642 | + return 1; | |
| 643 | +} | |
| 644 | + | |
| 645 | +void | |
| 646 | +rewinddir(DIR *d) | |
| 647 | +{ | |
| 648 | + FindClose(d->handle); | |
| 649 | + d->handle = FindFirstFile(d->path, &d->wfd); | |
| 650 | + d->index = 0; | |
| 651 | +} | |
| 652 | + | |
| 653 | +static int | |
| 654 | +chown(char *path, int uid, int perm) | |
| 655 | +{ | |
| 656 | +/* panic("chown"); */ | |
| 657 | + return 0; | |
| 658 | +} | |
| 659 | + | |
| 660 | +DIR* | |
| 661 | +opendir(char *p) | |
| 662 | +{ | |
| 663 | + DIR *d; | |
| 664 | + char path[MAX_PATH]; | |
| 665 | + | |
| 666 | + | |
| 667 | + snprint(path, sizeof(path), "%s/*.*", p); | |
| 668 | + | |
| 669 | + d = mallocz(sizeof(DIR), 1); | |
| 670 | + if(d == 0) | |
| 671 | + return 0; | |
| 672 | + | |
| 673 | + d->index = 0; | |
| 674 | + | |
| 675 | + d->handle = FindFirstFile(path, &d->wfd); | |
| 676 | + if(d->handle == INVALID_HANDLE_VALUE) { | |
| 677 | + free(d); | |
| 678 | + return 0; | |
| 679 | + } | |
| 680 | + | |
| 681 | + d->path = strdup(path); | |
| 682 | + return d; | |
| 683 | +} | |
| 684 | + | |
| 685 | +Dev fsdevtab = { | |
| 686 | + 'U', | |
| 687 | + "fs", | |
| 688 | + | |
| 689 | + devreset, | |
| 690 | + devinit, | |
| 691 | + devshutdown, | |
| 692 | + fsattach, | |
| 693 | + fswalk, | |
| 694 | + fsstat, | |
| 695 | + fsopen, | |
| 696 | + fscreate, | |
| 697 | + fsclose, | |
| 698 | + fsread, | |
| 699 | + devbread, | |
| 700 | + fswrite, | |
| 701 | + devbwrite, | |
| 702 | + fsremove, | |
| 703 | + fswstat, | |
| 704 | +}; | |
| @@ -0,0 +1,398 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +#include "netif.h" | |
| 8 | + | |
| 9 | +typedef struct Pipe Pipe; | |
| 10 | +struct Pipe | |
| 11 | +{ | |
| 12 | + QLock lk; | |
| 13 | + Pipe *next; | |
| 14 | + int ref; | |
| 15 | + ulong path; | |
| 16 | + Queue *q[2]; | |
| 17 | + int qref[2]; | |
| 18 | +}; | |
| 19 | + | |
| 20 | +struct | |
| 21 | +{ | |
| 22 | + Lock lk; | |
| 23 | + ulong path; | |
| 24 | +} pipealloc; | |
| 25 | + | |
| 26 | +enum | |
| 27 | +{ | |
| 28 | + Qdir, | |
| 29 | + Qdata0, | |
| 30 | + Qdata1, | |
| 31 | +}; | |
| 32 | + | |
| 33 | +Dirtab pipedir[] = | |
| 34 | +{ | |
| 35 | + ".", {Qdir,0,QTDIR}, 0, DMDIR|0500, | |
| 36 | + "data", {Qdata0}, 0, 0600, | |
| 37 | + "data1", {Qdata1}, 0, 0600, | |
| 38 | +}; | |
| 39 | +#define NPIPEDIR 3 | |
| 40 | + | |
| 41 | +static void | |
| 42 | +pipeinit(void) | |
| 43 | +{ | |
| 44 | + if(conf.pipeqsize == 0){ | |
| 45 | + if(conf.nmach > 1) | |
| 46 | + conf.pipeqsize = 256*1024; | |
| 47 | + else | |
| 48 | + conf.pipeqsize = 32*1024; | |
| 49 | + } | |
| 50 | +} | |
| 51 | + | |
| 52 | +/* | |
| 53 | + * create a pipe, no streams are created until an open | |
| 54 | + */ | |
| 55 | +static Chan* | |
| 56 | +pipeattach(char *spec) | |
| 57 | +{ | |
| 58 | + Pipe *p; | |
| 59 | + Chan *c; | |
| 60 | + | |
| 61 | + c = devattach('|', spec); | |
| 62 | + p = malloc(sizeof(Pipe)); | |
| 63 | + if(p == 0) | |
| 64 | + exhausted("memory"); | |
| 65 | + p->ref = 1; | |
| 66 | + | |
| 67 | + p->q[0] = qopen(conf.pipeqsize, 0, 0, 0); | |
| 68 | + if(p->q[0] == 0){ | |
| 69 | + free(p); | |
| 70 | + exhausted("memory"); | |
| 71 | + } | |
| 72 | + p->q[1] = qopen(conf.pipeqsize, 0, 0, 0); | |
| 73 | + if(p->q[1] == 0){ | |
| 74 | + free(p->q[0]); | |
| 75 | + free(p); | |
| 76 | + exhausted("memory"); | |
| 77 | + } | |
| 78 | + | |
| 79 | + lock(&pipealloc.lk); | |
| 80 | + p->path = ++pipealloc.path; | |
| 81 | + unlock(&pipealloc.lk); | |
| 82 | + | |
| 83 | + mkqid(&c->qid, NETQID(2*p->path, Qdir), 0, QTDIR); | |
| 84 | + c->aux = p; | |
| 85 | + c->dev = 0; | |
| 86 | + return c; | |
| 87 | +} | |
| 88 | + | |
| 89 | +static int | |
| 90 | +pipegen(Chan *c, char *name, Dirtab *tab, int ntab, int i, Dir *dp) | |
| 91 | +{ | |
| 92 | + Qid q; | |
| 93 | + int len; | |
| 94 | + Pipe *p; | |
| 95 | + | |
| 96 | + USED(name); | |
| 97 | + | |
| 98 | + if(i == DEVDOTDOT){ | |
| 99 | + devdir(c, c->qid, "#|", 0, eve, DMDIR|0555, dp); | |
| 100 | + return 1; | |
| 101 | + } | |
| 102 | + i++; /* skip . */ | |
| 103 | + if(tab==0 || i>=ntab) | |
| 104 | + return -1; | |
| 105 | + | |
| 106 | + tab += i; | |
| 107 | + p = c->aux; | |
| 108 | + switch((ulong)tab->qid.path){ | |
| 109 | + case Qdata0: | |
| 110 | + len = qlen(p->q[0]); | |
| 111 | + break; | |
| 112 | + case Qdata1: | |
| 113 | + len = qlen(p->q[1]); | |
| 114 | + break; | |
| 115 | + default: | |
| 116 | + len = tab->length; | |
| 117 | + break; | |
| 118 | + } | |
| 119 | + mkqid(&q, NETQID(NETID(c->qid.path), tab->qid.path), 0, QTFILE); | |
| 120 | + devdir(c, q, tab->name, len, eve, tab->perm, dp); | |
| 121 | + return 1; | |
| 122 | +} | |
| 123 | + | |
| 124 | + | |
| 125 | +static Walkqid* | |
| 126 | +pipewalk(Chan *c, Chan *nc, char **name, int nname) | |
| 127 | +{ | |
| 128 | + Walkqid *wq; | |
| 129 | + Pipe *p; | |
| 130 | + | |
| 131 | + wq = devwalk(c, nc, name, nname, pipedir, NPIPEDIR, pipegen); | |
| 132 | + if(wq != nil && wq->clone != nil && wq->clone != c){ | |
| 133 | + p = c->aux; | |
| 134 | + qlock(&p->lk); | |
| 135 | + p->ref++; | |
| 136 | + if(c->flag & COPEN){ | |
| 137 | + print("channel open in pipewalk\n"); | |
| 138 | + switch(NETTYPE(c->qid.path)){ | |
| 139 | + case Qdata0: | |
| 140 | + p->qref[0]++; | |
| 141 | + break; | |
| 142 | + case Qdata1: | |
| 143 | + p->qref[1]++; | |
| 144 | + break; | |
| 145 | + } | |
| 146 | + } | |
| 147 | + qunlock(&p->lk); | |
| 148 | + } | |
| 149 | + return wq; | |
| 150 | +} | |
| 151 | + | |
| 152 | +static int | |
| 153 | +pipestat(Chan *c, uchar *db, int n) | |
| 154 | +{ | |
| 155 | + Pipe *p; | |
| 156 | + Dir dir; | |
| 157 | + | |
| 158 | + p = c->aux; | |
| 159 | + | |
| 160 | + switch(NETTYPE(c->qid.path)){ | |
| 161 | + case Qdir: | |
| 162 | + devdir(c, c->qid, ".", 0, eve, DMDIR|0555, &dir); | |
| 163 | + break; | |
| 164 | + case Qdata0: | |
| 165 | + devdir(c, c->qid, "data", qlen(p->q[0]), eve, 0600, &dir); | |
| 166 | + break; | |
| 167 | + case Qdata1: | |
| 168 | + devdir(c, c->qid, "data1", qlen(p->q[1]), eve, 0600, &dir); | |
| 169 | + break; | |
| 170 | + default: | |
| 171 | + panic("pipestat"); | |
| 172 | + } | |
| 173 | + n = convD2M(&dir, db, n); | |
| 174 | + if(n < BIT16SZ) | |
| 175 | + error(Eshortstat); | |
| 176 | + return n; | |
| 177 | +} | |
| 178 | + | |
| 179 | +/* | |
| 180 | + * if the stream doesn't exist, create it | |
| 181 | + */ | |
| 182 | +static Chan* | |
| 183 | +pipeopen(Chan *c, int omode) | |
| 184 | +{ | |
| 185 | + Pipe *p; | |
| 186 | + | |
| 187 | + if(c->qid.type & QTDIR){ | |
| 188 | + if(omode != OREAD) | |
| 189 | + error(Ebadarg); | |
| 190 | + c->mode = omode; | |
| 191 | + c->flag |= COPEN; | |
| 192 | + c->offset = 0; | |
| 193 | + return c; | |
| 194 | + } | |
| 195 | + | |
| 196 | + p = c->aux; | |
| 197 | + qlock(&p->lk); | |
| 198 | + switch(NETTYPE(c->qid.path)){ | |
| 199 | + case Qdata0: | |
| 200 | + p->qref[0]++; | |
| 201 | + break; | |
| 202 | + case Qdata1: | |
| 203 | + p->qref[1]++; | |
| 204 | + break; | |
| 205 | + } | |
| 206 | + qunlock(&p->lk); | |
| 207 | + | |
| 208 | + c->mode = openmode(omode); | |
| 209 | + c->flag |= COPEN; | |
| 210 | + c->offset = 0; | |
| 211 | + c->iounit = qiomaxatomic; | |
| 212 | + return c; | |
| 213 | +} | |
| 214 | + | |
| 215 | +static void | |
| 216 | +pipeclose(Chan *c) | |
| 217 | +{ | |
| 218 | + Pipe *p; | |
| 219 | + | |
| 220 | + p = c->aux; | |
| 221 | + qlock(&p->lk); | |
| 222 | + | |
| 223 | + if(c->flag & COPEN){ | |
| 224 | + /* | |
| 225 | + * closing either side hangs up the stream | |
| 226 | + */ | |
| 227 | + switch(NETTYPE(c->qid.path)){ | |
| 228 | + case Qdata0: | |
| 229 | + p->qref[0]--; | |
| 230 | + if(p->qref[0] == 0){ | |
| 231 | + qhangup(p->q[1], 0); | |
| 232 | + qclose(p->q[0]); | |
| 233 | + } | |
| 234 | + break; | |
| 235 | + case Qdata1: | |
| 236 | + p->qref[1]--; | |
| 237 | + if(p->qref[1] == 0){ | |
| 238 | + qhangup(p->q[0], 0); | |
| 239 | + qclose(p->q[1]); | |
| 240 | + } | |
| 241 | + break; | |
| 242 | + } | |
| 243 | + } | |
| 244 | + | |
| 245 | + | |
| 246 | + /* | |
| 247 | + * if both sides are closed, they are reusable | |
| 248 | + */ | |
| 249 | + if(p->qref[0] == 0 && p->qref[1] == 0){ | |
| 250 | + qreopen(p->q[0]); | |
| 251 | + qreopen(p->q[1]); | |
| 252 | + } | |
| 253 | + | |
| 254 | + /* | |
| 255 | + * free the structure on last close | |
| 256 | + */ | |
| 257 | + p->ref--; | |
| 258 | + if(p->ref == 0){ | |
| 259 | + qunlock(&p->lk); | |
| 260 | + free(p->q[0]); | |
| 261 | + free(p->q[1]); | |
| 262 | + free(p); | |
| 263 | + } else | |
| 264 | + qunlock(&p->lk); | |
| 265 | +} | |
| 266 | + | |
| 267 | +static long | |
| 268 | +piperead(Chan *c, void *va, long n, vlong offset) | |
| 269 | +{ | |
| 270 | + Pipe *p; | |
| 271 | + | |
| 272 | + USED(offset); | |
| 273 | + | |
| 274 | + p = c->aux; | |
| 275 | + | |
| 276 | + switch(NETTYPE(c->qid.path)){ | |
| 277 | + case Qdir: | |
| 278 | + return devdirread(c, va, n, pipedir, NPIPEDIR, pipegen); | |
| 279 | + case Qdata0: | |
| 280 | + return qread(p->q[0], va, n); | |
| 281 | + case Qdata1: | |
| 282 | + return qread(p->q[1], va, n); | |
| 283 | + default: | |
| 284 | + panic("piperead"); | |
| 285 | + } | |
| 286 | + return -1; /* not reached */ | |
| 287 | +} | |
| 288 | + | |
| 289 | +static Block* | |
| 290 | +pipebread(Chan *c, long n, ulong offset) | |
| 291 | +{ | |
| 292 | + Pipe *p; | |
| 293 | + | |
| 294 | + p = c->aux; | |
| 295 | + | |
| 296 | + switch(NETTYPE(c->qid.path)){ | |
| 297 | + case Qdata0: | |
| 298 | + return qbread(p->q[0], n); | |
| 299 | + case Qdata1: | |
| 300 | + return qbread(p->q[1], n); | |
| 301 | + } | |
| 302 | + | |
| 303 | + return devbread(c, n, offset); | |
| 304 | +} | |
| 305 | + | |
| 306 | +/* | |
| 307 | + * a write to a closed pipe causes a note to be sent to | |
| 308 | + * the process. | |
| 309 | + */ | |
| 310 | +static long | |
| 311 | +pipewrite(Chan *c, void *va, long n, vlong offset) | |
| 312 | +{ | |
| 313 | + Pipe *p; | |
| 314 | + | |
| 315 | + USED(offset); | |
| 316 | + if(!islo()) | |
| 317 | + print("pipewrite hi %lux\n", getcallerpc(&c)); | |
| 318 | + | |
| 319 | + if(waserror()) { | |
| 320 | + /* avoid notes when pipe is a mounted queue */ | |
| 321 | + if((c->flag & CMSG) == 0) | |
| 322 | + postnote(up, 1, "sys: write on closed pipe", NUser); | |
| 323 | + nexterror(); | |
| 324 | + } | |
| 325 | + | |
| 326 | + p = c->aux; | |
| 327 | + | |
| 328 | + switch(NETTYPE(c->qid.path)){ | |
| 329 | + case Qdata0: | |
| 330 | + n = qwrite(p->q[1], va, n); | |
| 331 | + break; | |
| 332 | + | |
| 333 | + case Qdata1: | |
| 334 | + n = qwrite(p->q[0], va, n); | |
| 335 | + break; | |
| 336 | + | |
| 337 | + default: | |
| 338 | + panic("pipewrite"); | |
| 339 | + } | |
| 340 | + | |
| 341 | + poperror(); | |
| 342 | + return n; | |
| 343 | +} | |
| 344 | + | |
| 345 | +static long | |
| 346 | +pipebwrite(Chan *c, Block *bp, ulong offset) | |
| 347 | +{ | |
| 348 | + long n; | |
| 349 | + Pipe *p; | |
| 350 | + | |
| 351 | + USED(offset); | |
| 352 | + | |
| 353 | + if(waserror()) { | |
| 354 | + /* avoid notes when pipe is a mounted queue */ | |
| 355 | + if((c->flag & CMSG) == 0) | |
| 356 | + postnote(up, 1, "sys: write on closed pipe", NUser); | |
| 357 | + nexterror(); | |
| 358 | + } | |
| 359 | + | |
| 360 | + p = c->aux; | |
| 361 | + switch(NETTYPE(c->qid.path)){ | |
| 362 | + case Qdata0: | |
| 363 | + n = qbwrite(p->q[1], bp); | |
| 364 | + break; | |
| 365 | + | |
| 366 | + case Qdata1: | |
| 367 | + n = qbwrite(p->q[0], bp); | |
| 368 | + break; | |
| 369 | + | |
| 370 | + default: | |
| 371 | + n = 0; | |
| 372 | + panic("pipebwrite"); | |
| 373 | + } | |
| 374 | + | |
| 375 | + poperror(); | |
| 376 | + return n; | |
| 377 | +} | |
| 378 | + | |
| 379 | +Dev pipedevtab = { | |
| 380 | + '|', | |
| 381 | + "pipe", | |
| 382 | + | |
| 383 | + devreset, | |
| 384 | + pipeinit, | |
| 385 | + devshutdown, | |
| 386 | + pipeattach, | |
| 387 | + pipewalk, | |
| 388 | + pipestat, | |
| 389 | + pipeopen, | |
| 390 | + devcreate, | |
| 391 | + pipeclose, | |
| 392 | + piperead, | |
| 393 | + pipebread, | |
| 394 | + pipewrite, | |
| 395 | + pipebwrite, | |
| 396 | + devremove, | |
| 397 | + devwstat, | |
| 398 | +}; | |
| @@ -0,0 +1,268 @@ | ||
| 1 | +#include "u.h" | |
| 2 | +#include "lib.h" | |
| 3 | +#include "dat.h" | |
| 4 | +#include "fns.h" | |
| 5 | +#include "error.h" | |
| 6 | + | |
| 7 | +enum | |
| 8 | +{ | |
| 9 | + Qdir = 0, | |
| 10 | + Qboot = 0x1000, | |
| 11 | + | |
| 12 | + Nrootfiles = 32, | |
| 13 | + Nbootfiles = 32, | |
| 14 | +}; | |
| 15 | + | |
| 16 | +typedef struct Dirlist Dirlist; | |
| 17 | +struct Dirlist | |
| 18 | +{ | |
| 19 | + uint base; | |
| 20 | + Dirtab *dir; | |
| 21 | + uchar **data; | |
| 22 | + int ndir; | |
| 23 | + int mdir; | |
| 24 | +}; | |
| 25 | + | |
| 26 | +static Dirtab rootdir[Nrootfiles] = { | |
| 27 | + "#/", {Qdir, 0, QTDIR}, 0, DMDIR|0555, | |
| 28 | + "boot", {Qboot, 0, QTDIR}, 0, DMDIR|0555, | |
| 29 | +}; | |
| 30 | +static uchar *rootdata[Nrootfiles]; | |
| 31 | +static Dirlist rootlist = | |
| 32 | +{ | |
| 33 | + 0, | |
| 34 | + rootdir, | |
| 35 | + rootdata, | |
| 36 | + 2, | |
| 37 | + Nrootfiles | |
| 38 | +}; | |
| 39 | + | |
| 40 | +static Dirtab bootdir[Nbootfiles] = { | |
| 41 | + "boot", {Qboot, 0, QTDIR}, 0, DMDIR|0555, | |
| 42 | +}; | |
| 43 | +static uchar *bootdata[Nbootfiles]; | |
| 44 | +static Dirlist bootlist = | |
| 45 | +{ | |
| 46 | + Qboot, | |
| 47 | + bootdir, | |
| 48 | + bootdata, | |
| 49 | + 1, | |
| 50 | + Nbootfiles | |
| 51 | +}; | |
| 52 | + | |
| 53 | +/* | |
| 54 | + * add a file to the list | |
| 55 | + */ | |
| 56 | +static void | |
| 57 | +addlist(Dirlist *l, char *name, uchar *contents, ulong len, int perm) | |
| 58 | +{ | |
| 59 | + Dirtab *d; | |
| 60 | + | |
| 61 | + if(l->ndir >= l->mdir) | |
| 62 | + panic("too many root files"); | |
| 63 | + l->data[l->ndir] = contents; | |
| 64 | + d = &l->dir[l->ndir]; | |
| 65 | + strcpy(d->name, name); | |
| 66 | + d->length = len; | |
| 67 | + d->perm = perm; | |
| 68 | + d->qid.type = 0; | |
| 69 | + d->qid.vers = 0; | |
| 70 | + d->qid.path = ++l->ndir + l->base; | |
| 71 | + if(perm & DMDIR) | |
| 72 | + d->qid.type |= QTDIR; | |
| 73 | +} | |
| 74 | + | |
| 75 | +/* | |
| 76 | + * add a root file | |
| 77 | + */ | |
| 78 | +void | |
| 79 | +addbootfile(char *name, uchar *contents, ulong len) | |
| 80 | +{ | |
| 81 | + addlist(&bootlist, name, contents, len, 0555); | |
| 82 | +} | |
| 83 | + | |
| 84 | +/* | |
| 85 | + * add a root directory | |
| 86 | + */ | |
| 87 | +static void | |
| 88 | +addrootdir(char *name) | |
| 89 | +{ | |
| 90 | + addlist(&rootlist, name, nil, 0, DMDIR|0555); | |
| 91 | +} | |
| 92 | + | |
| 93 | +static void | |
| 94 | +rootreset(void) | |
| 95 | +{ | |
| 96 | + addrootdir("bin"); | |
| 97 | + addrootdir("dev"); | |
| 98 | + addrootdir("env"); | |
| 99 | + addrootdir("fd"); | |
| 100 | + addrootdir("mnt"); | |
| 101 | + addrootdir("net"); | |
| 102 | + addrootdir("net.alt"); | |
| 103 | + addrootdir("proc"); | |
| 104 | + addrootdir("root"); | |
| 105 | + addrootdir("srv"); | |
| 106 | +} | |
| 107 | + | |
| 108 | +static Chan* | |
| 109 | +rootattach(char *spec) | |
| 110 | +{ | |
| 111 | + return devattach('/', spec); | |
| 112 | +} | |
| 113 | + | |
| 114 | +static int | |
| 115 | +rootgen(Chan *c, char *name, Dirtab *dirt, int ndirt, int s, Dir *dp) | |
| 116 | +{ | |
| 117 | + int t; | |
| 118 | + Dirtab *d; | |
| 119 | + Dirlist *l; | |
| 120 | + | |
| 121 | + USED(dirt); | |
| 122 | + USED(ndirt); | |
| 123 | + | |
| 124 | + switch((int)c->qid.path){ | |
| 125 | + case Qdir: | |
| 126 | + if(s == DEVDOTDOT){ | |
| 127 | + Qid tqiddir = {Qdir, 0, QTDIR}; | |
| 128 | + devdir(c, tqiddir, "#/", 0, eve, 0555, dp); | |
| 129 | + return 1; | |
| 130 | + } | |
| 131 | + return devgen(c, name, rootlist.dir, rootlist.ndir, s, dp); | |
| 132 | + case Qboot: | |
| 133 | + if(s == DEVDOTDOT){ | |
| 134 | + Qid tqiddir = {Qdir, 0, QTDIR}; | |
| 135 | + devdir(c, tqiddir, "#/", 0, eve, 0555, dp); | |
| 136 | + return 1; | |
| 137 | + } | |
| 138 | + return devgen(c, name, bootlist.dir, bootlist.ndir, s, dp); | |
| 139 | + default: | |
| 140 | + if(s == DEVDOTDOT){ | |
| 141 | + Qid tqiddir = {Qdir, 0, QTDIR}; | |
| 142 | + if((int)c->qid.path < Qboot) | |
| 143 | + devdir(c, tqiddir, "#/", 0, eve, 0555, dp); | |
| 144 | + else { | |
| 145 | + tqiddir.path = Qboot; | |
| 146 | + devdir(c, tqiddir, "#/", 0, eve, 0555, dp); | |
| 147 | + } | |
| 148 | + return 1; | |
| 149 | + } | |
| 150 | + if(s != 0) | |
| 151 | + return -1; | |
| 152 | + if((int)c->qid.path < Qboot){ | |
| 153 | + t = c->qid.path-1; | |
| 154 | + l = &rootlist; | |
| 155 | + }else{ | |
| 156 | + t = c->qid.path - Qboot - 1; | |
| 157 | + l = &bootlist; | |
| 158 | + } | |
| 159 | + if(t >= l->ndir) | |
| 160 | + return -1; | |
| 161 | +if(t < 0){ | |
| 162 | +print("rootgen %llud %d %d\n", c->qid.path, s, t); | |
| 163 | +panic("whoops"); | |
| 164 | +} | |
| 165 | + d = &l->dir[t]; | |
| 166 | + devdir(c, d->qid, d->name, d->length, eve, d->perm, dp); | |
| 167 | + return 1; | |
| 168 | + } | |
| 169 | + return -1; | |
| 170 | +} | |
| 171 | + | |
| 172 | +static Walkqid* | |
| 173 | +rootwalk(Chan *c, Chan *nc, char **name, int nname) | |
| 174 | +{ | |
| 175 | + return devwalk(c, nc, name, nname, nil, 0, rootgen); | |
| 176 | +} | |
| 177 | + | |
| 178 | +static int | |
| 179 | +rootstat(Chan *c, uchar *dp, int n) | |
| 180 | +{ | |
| 181 | + return devstat(c, dp, n, nil, 0, rootgen); | |
| 182 | +} | |
| 183 | + | |
| 184 | +static Chan* | |
| 185 | +rootopen(Chan *c, int omode) | |
| 186 | +{ | |
| 187 | + return devopen(c, omode, nil, 0, devgen); | |
| 188 | +} | |
| 189 | + | |
| 190 | +/* | |
| 191 | + * sysremove() knows this is a nop | |
| 192 | + */ | |
| 193 | +static void | |
| 194 | +rootclose(Chan *c) | |
| 195 | +{ | |
| 196 | + USED(c); | |
| 197 | +} | |
| 198 | + | |
| 199 | +static long | |
| 200 | +rootread(Chan *c, void *buf, long n, vlong off) | |
| 201 | +{ | |
| 202 | + ulong t; | |
| 203 | + Dirtab *d; | |
| 204 | + Dirlist *l; | |
| 205 | + uchar *data; | |
| 206 | + ulong offset = off; | |
| 207 | + | |
| 208 | + t = c->qid.path; | |
| 209 | + switch(t){ | |
| 210 | + case Qdir: | |
| 211 | + case Qboot: | |
| 212 | + return devdirread(c, buf, n, nil, 0, rootgen); | |
| 213 | + } | |
| 214 | + | |
| 215 | + if(t<Qboot) | |
| 216 | + l = &rootlist; | |
| 217 | + else{ | |
| 218 | + t -= Qboot; | |
| 219 | + l = &bootlist; | |
| 220 | + } | |
| 221 | + | |
| 222 | + t--; | |
| 223 | + if(t >= l->ndir) | |
| 224 | + error(Egreg); | |
| 225 | + | |
| 226 | + d = &l->dir[t]; | |
| 227 | + data = l->data[t]; | |
| 228 | + if(offset >= d->length) | |
| 229 | + return 0; | |
| 230 | + if(offset+n > d->length) | |
| 231 | + n = d->length - offset; | |
| 232 | + memmove(buf, data+offset, n); | |
| 233 | + return n; | |
| 234 | +} | |
| 235 | + | |
| 236 | +static long | |
| 237 | +rootwrite(Chan *c, void *v, long n, vlong o) | |
| 238 | +{ | |
| 239 | + USED(c); | |
| 240 | + USED(v); | |
| 241 | + USED(n); | |
| 242 | + USED(o); | |
| 243 | + | |
| 244 | + error(Egreg); | |
| 245 | + return 0; | |
| 246 | +} | |
| 247 | + | |
| 248 | +Dev rootdevtab = { | |
| 249 | + '/', | |
| 250 | + "root", | |
| 251 | + | |
| 252 | + rootreset, | |
| 253 | + devinit, | |
| 254 | + devshutdown, | |
| 255 | + rootattach, | |
| 256 | + rootwalk, | |
| 257 | + rootstat, | |
| 258 | + rootopen, | |
| 259 | + devcreate, | |
| 260 | + rootclose, | |
| 261 | + rootread, | |
| 262 | + devbread, | |
| 263 | + rootwrite, | |
| 264 | + devbwrite, | |
| 265 | + devremove, | |
| 266 | + devwstat, | |
| 267 | +}; | |
| 268 | + | |
| @@ -0,0 +1,1512 @@ | ||
| 1 | +/* | |
| 2 | + * devssl - secure sockets layer | |
| 3 | + */ | |
| 4 | +#include "u.h" | |
| 5 | +#include "lib.h" | |
| 6 | +#include "dat.h" | |
| 7 | +#include "fns.h" | |
| 8 | +#include "error.h" | |
| 9 | + | |
| 10 | +#include "libsec.h" | |
| 11 | + | |
| 12 | +#define NOSPOOKS 1 | |
| 13 | + | |
| 14 | +typedef struct OneWay OneWay; | |
| 15 | +struct OneWay | |
| 16 | +{ | |
| 17 | + QLock q; | |
| 18 | + QLock ctlq; | |
| 19 | + | |
| 20 | + void *state; /* encryption state */ | |
| 21 | + int slen; /* hash data length */ | |
| 22 | + uchar *secret; /* secret */ | |
| 23 | + ulong mid; /* message id */ | |
| 24 | +}; | |
| 25 | + | |
| 26 | +enum | |
| 27 | +{ | |
| 28 | + /* connection states */ | |
| 29 | + Sincomplete= 0, | |
| 30 | + Sclear= 1, | |
| 31 | + Sencrypting= 2, | |
| 32 | + Sdigesting= 4, | |
| 33 | + Sdigenc= Sencrypting|Sdigesting, | |
| 34 | + | |
| 35 | + /* encryption algorithms */ | |
| 36 | + Noencryption= 0, | |
| 37 | + DESCBC= 1, | |
| 38 | + DESECB= 2, | |
| 39 | + RC4= 3 | |
| 40 | +}; | |
| 41 | + | |
| 42 | +typedef struct Dstate Dstate; | |
| 43 | +struct Dstate | |
| 44 | +{ | |
| 45 | + Chan *c; /* io channel */ | |
| 46 | + uchar state; /* state of connection */ | |
| 47 | + int ref; /* serialized by dslock for atomic destroy */ | |
| 48 | + | |
| 49 | + uchar encryptalg; /* encryption algorithm */ | |
| 50 | + ushort blocklen; /* blocking length */ | |
| 51 | + | |
| 52 | + ushort diglen; /* length of digest */ | |
| 53 | + DigestState *(*hf)(uchar*, ulong, uchar*, DigestState*); /* hash func */ | |
| 54 | + | |
| 55 | + /* for SSL format */ | |
| 56 | + int max; /* maximum unpadded data per msg */ | |
| 57 | + int maxpad; /* maximum padded data per msg */ | |
| 58 | + | |
| 59 | + /* input side */ | |
| 60 | + OneWay in; | |
| 61 | + Block *processed; | |
| 62 | + Block *unprocessed; | |
| 63 | + | |
| 64 | + /* output side */ | |
| 65 | + OneWay out; | |
| 66 | + | |
| 67 | + /* protections */ | |
| 68 | + char *user; | |
| 69 | + int perm; | |
| 70 | +}; | |
| 71 | + | |
| 72 | +enum | |
| 73 | +{ | |
| 74 | + Maxdmsg= 1<<16, | |
| 75 | + Maxdstate= 128, /* must be a power of 2 */ | |
| 76 | +}; | |
| 77 | + | |
| 78 | +Lock dslock; | |
| 79 | +int dshiwat; | |
| 80 | +char *dsname[Maxdstate]; | |
| 81 | +Dstate *dstate[Maxdstate]; | |
| 82 | +char *encalgs; | |
| 83 | +char *hashalgs; | |
| 84 | + | |
| 85 | +enum{ | |
| 86 | + Qtopdir = 1, /* top level directory */ | |
| 87 | + Qprotodir, | |
| 88 | + Qclonus, | |
| 89 | + Qconvdir, /* directory for a conversation */ | |
| 90 | + Qdata, | |
| 91 | + Qctl, | |
| 92 | + Qsecretin, | |
| 93 | + Qsecretout, | |
| 94 | + Qencalgs, | |
| 95 | + Qhashalgs, | |
| 96 | +}; | |
| 97 | + | |
| 98 | +#define TYPE(x) ((x).path & 0xf) | |
| 99 | +#define CONV(x) (((x).path >> 5)&(Maxdstate-1)) | |
| 100 | +#define QID(c, y) (((c)<<5) | (y)) | |
| 101 | + | |
| 102 | +static void ensure(Dstate*, Block**, int); | |
| 103 | +static void consume(Block**, uchar*, int); | |
| 104 | +static void setsecret(OneWay*, uchar*, int); | |
| 105 | +static Block* encryptb(Dstate*, Block*, int); | |
| 106 | +static Block* decryptb(Dstate*, Block*); | |
| 107 | +static Block* digestb(Dstate*, Block*, int); | |
| 108 | +static void checkdigestb(Dstate*, Block*); | |
| 109 | +static Chan* buftochan(char*); | |
| 110 | +static void sslhangup(Dstate*); | |
| 111 | +static Dstate* dsclone(Chan *c); | |
| 112 | +static void dsnew(Chan *c, Dstate **); | |
| 113 | +static long sslput(Dstate *s, Block * volatile b); | |
| 114 | + | |
| 115 | +char *sslnames[] = { | |
| 116 | + /* unused */ 0, | |
| 117 | + /* topdir */ 0, | |
| 118 | + /* protodir */ 0, | |
| 119 | + "clone", | |
| 120 | + /* convdir */ 0, | |
| 121 | + "data", | |
| 122 | + "ctl", | |
| 123 | + "secretin", | |
| 124 | + "secretout", | |
| 125 | + "encalgs", | |
| 126 | + "hashalgs", | |
| 127 | +}; | |
| 128 | + | |
| 129 | +static int | |
| 130 | +sslgen(Chan *c, char *n, Dirtab *d, int nd, int s, Dir *dp) | |
| 131 | +{ | |
| 132 | + Qid q; | |
| 133 | + Dstate *ds; | |
| 134 | + char name[16], *p, *nm; | |
| 135 | + int ft; | |
| 136 | + | |
| 137 | + USED(n); | |
| 138 | + USED(nd); | |
| 139 | + USED(d); | |
| 140 | + | |
| 141 | + q.type = QTFILE; | |
| 142 | + q.vers = 0; | |
| 143 | + | |
| 144 | + ft = TYPE(c->qid); | |
| 145 | + switch(ft) { | |
| 146 | + case Qtopdir: | |
| 147 | + if(s == DEVDOTDOT){ | |
| 148 | + q.path = QID(0, Qtopdir); | |
| 149 | + q.type = QTDIR; | |
| 150 | + devdir(c, q, "#D", 0, eve, 0555, dp); | |
| 151 | + return 1; | |
| 152 | + } | |
| 153 | + if(s > 0) | |
| 154 | + return -1; | |
| 155 | + q.path = QID(0, Qprotodir); | |
| 156 | + q.type = QTDIR; | |
| 157 | + devdir(c, q, "ssl", 0, eve, 0555, dp); | |
| 158 | + return 1; | |
| 159 | + case Qprotodir: | |
| 160 | + if(s == DEVDOTDOT){ | |
| 161 | + q.path = QID(0, Qtopdir); | |
| 162 | + q.type = QTDIR; | |
| 163 | + devdir(c, q, ".", 0, eve, 0555, dp); | |
| 164 | + return 1; | |
| 165 | + } | |
| 166 | + if(s < dshiwat) { | |
| 167 | + q.path = QID(s, Qconvdir); | |
| 168 | + q.type = QTDIR; | |
| 169 | + ds = dstate[s]; | |
| 170 | + if(ds != 0) | |
| 171 | + nm = ds->user; | |
| 172 | + else | |
| 173 | + nm = eve; | |
| 174 | + if(dsname[s] == nil){ | |
| 175 | + sprint(name, "%d", s); | |
| 176 | + kstrdup(&dsname[s], name); | |
| 177 | + } | |
| 178 | + devdir(c, q, dsname[s], 0, nm, 0555, dp); | |
| 179 | + return 1; | |
| 180 | + } | |
| 181 | + if(s > dshiwat) | |
| 182 | + return -1; | |
| 183 | + q.path = QID(0, Qclonus); | |
| 184 | + devdir(c, q, "clone", 0, eve, 0555, dp); | |
| 185 | + return 1; | |
| 186 | + case Qconvdir: | |
| 187 | + if(s == DEVDOTDOT){ | |
| 188 | + q.path = QID(0, Qprotodir); | |
| 189 | + q.type = QTDIR; | |
| 190 | + devdir(c, q, "ssl", 0, eve, 0555, dp); | |
| 191 | + return 1; | |
| 192 | + } | |
| 193 | + ds = dstate[CONV(c->qid)]; | |
| 194 | + if(ds != 0) | |
| 195 | + nm = ds->user; | |
| 196 | + else | |
| 197 | + nm = eve; | |
| 198 | + switch(s) { | |
| 199 | + default: | |
| 200 | + return -1; | |
| 201 | + case 0: | |
| 202 | + q.path = QID(CONV(c->qid), Qctl); | |
| 203 | + p = "ctl"; | |
| 204 | + break; | |
| 205 | + case 1: | |
| 206 | + q.path = QID(CONV(c->qid), Qdata); | |
| 207 | + p = "data"; | |
| 208 | + break; | |
| 209 | + case 2: | |
| 210 | + q.path = QID(CONV(c->qid), Qsecretin); | |
| 211 | + p = "secretin"; | |
| 212 | + break; | |
| 213 | + case 3: | |
| 214 | + q.path = QID(CONV(c->qid), Qsecretout); | |
| 215 | + p = "secretout"; | |
| 216 | + break; | |
| 217 | + case 4: | |
| 218 | + q.path = QID(CONV(c->qid), Qencalgs); | |
| 219 | + p = "encalgs"; | |
| 220 | + break; | |
| 221 | + case 5: | |
| 222 | + q.path = QID(CONV(c->qid), Qhashalgs); | |
| 223 | + p = "hashalgs"; | |
| 224 | + break; | |
| 225 | + } | |
| 226 | + devdir(c, q, p, 0, nm, 0660, dp); | |
| 227 | + return 1; | |
| 228 | + case Qclonus: | |
| 229 | + devdir(c, c->qid, sslnames[TYPE(c->qid)], 0, eve, 0555, dp); | |
| 230 | + return 1; | |
| 231 | + default: | |
| 232 | + ds = dstate[CONV(c->qid)]; | |
| 233 | + if(ds != 0) | |
| 234 | + nm = ds->user; | |
| 235 | + else | |
| 236 | + nm = eve; | |
| 237 | + devdir(c, c->qid, sslnames[TYPE(c->qid)], 0, nm, 0660, dp); | |
| 238 | + return 1; | |
| 239 | + } | |
| 240 | + return -1; | |
| 241 | +} | |
| 242 | + | |
| 243 | +static Chan* | |
| 244 | +sslattach(char *spec) | |
| 245 | +{ | |
| 246 | + Chan *c; | |
| 247 | + | |
| 248 | + c = devattach('D', spec); | |
| 249 | + c->qid.path = QID(0, Qtopdir); | |
| 250 | + c->qid.vers = 0; | |
| 251 | + c->qid.type = QTDIR; | |
| 252 | + return c; | |
| 253 | +} | |
| 254 | + | |
| 255 | +static Walkqid* | |
| 256 | +sslwalk(Chan *c, Chan *nc, char **name, int nname) | |
| 257 | +{ | |
| 258 | + return devwalk(c, nc, name, nname, nil, 0, sslgen); | |
| 259 | +} | |
| 260 | + | |
| 261 | +static int | |
| 262 | +sslstat(Chan *c, uchar *db, int n) | |
| 263 | +{ | |
| 264 | + return devstat(c, db, n, nil, 0, sslgen); | |
| 265 | +} | |
| 266 | + | |
| 267 | +static Chan* | |
| 268 | +sslopen(Chan *c, int omode) | |
| 269 | +{ | |
| 270 | + Dstate *s, **pp; | |
| 271 | + int perm; | |
| 272 | + int ft; | |
| 273 | + | |
| 274 | + perm = 0; | |
| 275 | + omode &= 3; | |
| 276 | + switch(omode) { | |
| 277 | + case OREAD: | |
| 278 | + perm = 4; | |
| 279 | + break; | |
| 280 | + case OWRITE: | |
| 281 | + perm = 2; | |
| 282 | + break; | |
| 283 | + case ORDWR: | |
| 284 | + perm = 6; | |
| 285 | + break; | |
| 286 | + } | |
| 287 | + | |
| 288 | + ft = TYPE(c->qid); | |
| 289 | + switch(ft) { | |
| 290 | + default: | |
| 291 | + panic("sslopen"); | |
| 292 | + case Qtopdir: | |
| 293 | + case Qprotodir: | |
| 294 | + case Qconvdir: | |
| 295 | + if(omode != OREAD) | |
| 296 | + error(Eperm); | |
| 297 | + break; | |
| 298 | + case Qclonus: | |
| 299 | + s = dsclone(c); | |
| 300 | + if(s == 0) | |
| 301 | + error(Enodev); | |
| 302 | + break; | |
| 303 | + case Qctl: | |
| 304 | + case Qdata: | |
| 305 | + case Qsecretin: | |
| 306 | + case Qsecretout: | |
| 307 | + if(waserror()) { | |
| 308 | + unlock(&dslock); | |
| 309 | + nexterror(); | |
| 310 | + } | |
| 311 | + lock(&dslock); | |
| 312 | + pp = &dstate[CONV(c->qid)]; | |
| 313 | + s = *pp; | |
| 314 | + if(s == 0) | |
| 315 | + dsnew(c, pp); | |
| 316 | + else { | |
| 317 | + if((perm & (s->perm>>6)) != perm | |
| 318 | + && (strcmp(up->user, s->user) != 0 | |
| 319 | + || (perm & s->perm) != perm)) | |
| 320 | + error(Eperm); | |
| 321 | + | |
| 322 | + s->ref++; | |
| 323 | + } | |
| 324 | + unlock(&dslock); | |
| 325 | + poperror(); | |
| 326 | + break; | |
| 327 | + case Qencalgs: | |
| 328 | + case Qhashalgs: | |
| 329 | + if(omode != OREAD) | |
| 330 | + error(Eperm); | |
| 331 | + break; | |
| 332 | + } | |
| 333 | + c->mode = openmode(omode); | |
| 334 | + c->flag |= COPEN; | |
| 335 | + c->offset = 0; | |
| 336 | + return c; | |
| 337 | +} | |
| 338 | + | |
| 339 | +static int | |
| 340 | +sslwstat(Chan *c, uchar *db, int n) | |
| 341 | +{ | |
| 342 | + Dir *dir; | |
| 343 | + Dstate *s; | |
| 344 | + int m; | |
| 345 | + | |
| 346 | + s = dstate[CONV(c->qid)]; | |
| 347 | + if(s == 0) | |
| 348 | + error(Ebadusefd); | |
| 349 | + if(strcmp(s->user, up->user) != 0) | |
| 350 | + error(Eperm); | |
| 351 | + | |
| 352 | + dir = smalloc(sizeof(Dir)+n); | |
| 353 | + m = convM2D(db, n, &dir[0], (char*)&dir[1]); | |
| 354 | + if(m == 0){ | |
| 355 | + free(dir); | |
| 356 | + error(Eshortstat); | |
| 357 | + } | |
| 358 | + | |
| 359 | + if(!emptystr(dir->uid)) | |
| 360 | + kstrdup(&s->user, dir->uid); | |
| 361 | + if(dir->mode != ~0UL) | |
| 362 | + s->perm = dir->mode; | |
| 363 | + | |
| 364 | + free(dir); | |
| 365 | + return m; | |
| 366 | +} | |
| 367 | + | |
| 368 | +static void | |
| 369 | +sslclose(Chan *c) | |
| 370 | +{ | |
| 371 | + Dstate *s; | |
| 372 | + int ft; | |
| 373 | + | |
| 374 | + ft = TYPE(c->qid); | |
| 375 | + switch(ft) { | |
| 376 | + case Qctl: | |
| 377 | + case Qdata: | |
| 378 | + case Qsecretin: | |
| 379 | + case Qsecretout: | |
| 380 | + if((c->flag & COPEN) == 0) | |
| 381 | + break; | |
| 382 | + | |
| 383 | + s = dstate[CONV(c->qid)]; | |
| 384 | + if(s == 0) | |
| 385 | + break; | |
| 386 | + | |
| 387 | + lock(&dslock); | |
| 388 | + if(--s->ref > 0) { | |
| 389 | + unlock(&dslock); | |
| 390 | + break; | |
| 391 | + } | |
| 392 | + dstate[CONV(c->qid)] = 0; | |
| 393 | + unlock(&dslock); | |
| 394 | + | |
| 395 | + if(s->user != nil) | |
| 396 | + free(s->user); | |
| 397 | + sslhangup(s); | |
| 398 | + if(s->c) | |
| 399 | + cclose(s->c); | |
| 400 | + if(s->in.secret) | |
| 401 | + free(s->in.secret); | |
| 402 | + if(s->out.secret) | |
| 403 | + free(s->out.secret); | |
| 404 | + if(s->in.state) | |
| 405 | + free(s->in.state); | |
| 406 | + if(s->out.state) | |
| 407 | + free(s->out.state); | |
| 408 | + free(s); | |
| 409 | + | |
| 410 | + } | |
| 411 | +} | |
| 412 | + | |
| 413 | +/* | |
| 414 | + * make sure we have at least 'n' bytes in list 'l' | |
| 415 | + */ | |
| 416 | +static void | |
| 417 | +ensure(Dstate *s, Block **l, int n) | |
| 418 | +{ | |
| 419 | + int sofar, i; | |
| 420 | + Block *b, *bl; | |
| 421 | + | |
| 422 | + sofar = 0; | |
| 423 | + for(b = *l; b; b = b->next){ | |
| 424 | + sofar += BLEN(b); | |
| 425 | + if(sofar >= n) | |
| 426 | + return; | |
| 427 | + l = &b->next; | |
| 428 | + } | |
| 429 | + | |
| 430 | + while(sofar < n){ | |
| 431 | + bl = devtab[s->c->type]->bread(s->c, Maxdmsg, 0); | |
| 432 | + if(bl == 0) | |
| 433 | + nexterror(); | |
| 434 | + *l = bl; | |
| 435 | + i = 0; | |
| 436 | + for(b = bl; b; b = b->next){ | |
| 437 | + i += BLEN(b); | |
| 438 | + l = &b->next; | |
| 439 | + } | |
| 440 | + if(i == 0) | |
| 441 | + error(Ehungup); | |
| 442 | + sofar += i; | |
| 443 | + } | |
| 444 | +} | |
| 445 | + | |
| 446 | +/* | |
| 447 | + * copy 'n' bytes from 'l' into 'p' and free | |
| 448 | + * the bytes in 'l' | |
| 449 | + */ | |
| 450 | +static void | |
| 451 | +consume(Block **l, uchar *p, int n) | |
| 452 | +{ | |
| 453 | + Block *b; | |
| 454 | + int i; | |
| 455 | + | |
| 456 | + for(; *l && n > 0; n -= i){ | |
| 457 | + b = *l; | |
| 458 | + i = BLEN(b); | |
| 459 | + if(i > n) | |
| 460 | + i = n; | |
| 461 | + memmove(p, b->rp, i); | |
| 462 | + b->rp += i; | |
| 463 | + p += i; | |
| 464 | + if(BLEN(b) < 0) | |
| 465 | + panic("consume"); | |
| 466 | + if(BLEN(b)) | |
| 467 | + break; | |
| 468 | + *l = b->next; | |
| 469 | + freeb(b); | |
| 470 | + } | |
| 471 | +} | |
| 472 | + | |
| 473 | +/* | |
| 474 | + * give back n bytes | |
| 475 | +static void | |
| 476 | +regurgitate(Dstate *s, uchar *p, int n) | |
| 477 | +{ | |
| 478 | + Block *b; | |
| 479 | + | |
| 480 | + if(n <= 0) | |
| 481 | + return; | |
| 482 | + b = s->unprocessed; | |
| 483 | + if(s->unprocessed == nil || b->rp - b->base < n) { | |
| 484 | + b = allocb(n); | |
| 485 | + memmove(b->wp, p, n); | |
| 486 | + b->wp += n; | |
| 487 | + b->next = s->unprocessed; | |
| 488 | + s->unprocessed = b; | |
| 489 | + } else { | |
| 490 | + b->rp -= n; | |
| 491 | + memmove(b->rp, p, n); | |
| 492 | + } | |
| 493 | +} | |
| 494 | + */ | |
| 495 | + | |
| 496 | +/* | |
| 497 | + * remove at most n bytes from the queue, if discard is set | |
| 498 | + * dump the remainder | |
| 499 | + */ | |
| 500 | +static Block* | |
| 501 | +qtake(Block **l, int n, int discard) | |
| 502 | +{ | |
| 503 | + Block *nb, *b, *first; | |
| 504 | + int i; | |
| 505 | + | |
| 506 | + first = *l; | |
| 507 | + for(b = first; b; b = b->next){ | |
| 508 | + i = BLEN(b); | |
| 509 | + if(i == n){ | |
| 510 | + if(discard){ | |
| 511 | + freeblist(b->next); | |
| 512 | + *l = 0; | |
| 513 | + } else | |
| 514 | + *l = b->next; | |
| 515 | + b->next = 0; | |
| 516 | + return first; | |
| 517 | + } else if(i > n){ | |
| 518 | + i -= n; | |
| 519 | + if(discard){ | |
| 520 | + freeblist(b->next); | |
| 521 | + b->wp -= i; | |
| 522 | + *l = 0; | |
| 523 | + } else { | |
| 524 | + nb = allocb(i); | |
| 525 | + memmove(nb->wp, b->rp+n, i); | |
| 526 | + nb->wp += i; | |
| 527 | + b->wp -= i; | |
| 528 | + nb->next = b->next; | |
| 529 | + *l = nb; | |
| 530 | + } | |
| 531 | + b->next = 0; | |
| 532 | + if(BLEN(b) < 0) | |
| 533 | + panic("qtake"); | |
| 534 | + return first; | |
| 535 | + } else | |
| 536 | + n -= i; | |
| 537 | + if(BLEN(b) < 0) | |
| 538 | + panic("qtake"); | |
| 539 | + } | |
| 540 | + *l = 0; | |
| 541 | + return first; | |
| 542 | +} | |
| 543 | + | |
| 544 | +/* | |
| 545 | + * We can't let Eintr's lose data since the program | |
| 546 | + * doing the read may be able to handle it. The only | |
| 547 | + * places Eintr is possible is during the read's in consume. | |
| 548 | + * Therefore, we make sure we can always put back the bytes | |
| 549 | + * consumed before the last ensure. | |
| 550 | + */ | |
| 551 | +static Block* | |
| 552 | +sslbread(Chan *c, long n, ulong o) | |
| 553 | +{ | |
| 554 | + Dstate * volatile s; | |
| 555 | + Block *b; | |
| 556 | + uchar consumed[3], *p; | |
| 557 | + int toconsume; | |
| 558 | + int len, pad; | |
| 559 | + | |
| 560 | + USED(o); | |
| 561 | + s = dstate[CONV(c->qid)]; | |
| 562 | + if(s == 0) | |
| 563 | + panic("sslbread"); | |
| 564 | + if(s->state == Sincomplete) | |
| 565 | + error(Ebadusefd); | |
| 566 | + | |
| 567 | + qlock(&s->in.q); | |
| 568 | + if(waserror()){ | |
| 569 | + qunlock(&s->in.q); | |
| 570 | + nexterror(); | |
| 571 | + } | |
| 572 | + | |
| 573 | + if(s->processed == 0){ | |
| 574 | + /* | |
| 575 | + * Read in the whole message. Until we've got it all, | |
| 576 | + * it stays on s->unprocessed, so that if we get Eintr, | |
| 577 | + * we'll pick up where we left off. | |
| 578 | + */ | |
| 579 | + ensure(s, &s->unprocessed, 3); | |
| 580 | + s->unprocessed = pullupblock(s->unprocessed, 2); | |
| 581 | + p = s->unprocessed->rp; | |
| 582 | + if(p[0] & 0x80){ | |
| 583 | + len = ((p[0] & 0x7f)<<8) | p[1]; | |
| 584 | + ensure(s, &s->unprocessed, len); | |
| 585 | + pad = 0; | |
| 586 | + toconsume = 2; | |
| 587 | + } else { | |
| 588 | + s->unprocessed = pullupblock(s->unprocessed, 3); | |
| 589 | + len = ((p[0] & 0x3f)<<8) | p[1]; | |
| 590 | + pad = p[2]; | |
| 591 | + if(pad > len){ | |
| 592 | + print("pad %d buf len %d\n", pad, len); | |
| 593 | + error("bad pad in ssl message"); | |
| 594 | + } | |
| 595 | + toconsume = 3; | |
| 596 | + } | |
| 597 | + ensure(s, &s->unprocessed, toconsume+len); | |
| 598 | + | |
| 599 | + /* skip header */ | |
| 600 | + consume(&s->unprocessed, consumed, toconsume); | |
| 601 | + | |
| 602 | + /* grab the next message and decode/decrypt it */ | |
| 603 | + b = qtake(&s->unprocessed, len, 0); | |
| 604 | + | |
| 605 | + if(blocklen(b) != len) | |
| 606 | + print("devssl: sslbread got wrong count %d != %d", blocklen(b), len); | |
| 607 | + | |
| 608 | + if(waserror()){ | |
| 609 | + qunlock(&s->in.ctlq); | |
| 610 | + if(b != nil) | |
| 611 | + freeb(b); | |
| 612 | + nexterror(); | |
| 613 | + } | |
| 614 | + qlock(&s->in.ctlq); | |
| 615 | + switch(s->state){ | |
| 616 | + case Sencrypting: | |
| 617 | + if(b == nil) | |
| 618 | + error("ssl message too short (encrypting)"); | |
| 619 | + b = decryptb(s, b); | |
| 620 | + break; | |
| 621 | + case Sdigesting: | |
| 622 | + b = pullupblock(b, s->diglen); | |
| 623 | + if(b == nil) | |
| 624 | + error("ssl message too short (digesting)"); | |
| 625 | + checkdigestb(s, b); | |
| 626 | + b->rp += s->diglen; | |
| 627 | + break; | |
| 628 | + case Sdigenc: | |
| 629 | + b = decryptb(s, b); | |
| 630 | + b = pullupblock(b, s->diglen); | |
| 631 | + if(b == nil) | |
| 632 | + error("ssl message too short (dig+enc)"); | |
| 633 | + checkdigestb(s, b); | |
| 634 | + b->rp += s->diglen; | |
| 635 | + len -= s->diglen; | |
| 636 | + break; | |
| 637 | + } | |
| 638 | + | |
| 639 | + /* remove pad */ | |
| 640 | + if(pad) | |
| 641 | + s->processed = qtake(&b, len - pad, 1); | |
| 642 | + else | |
| 643 | + s->processed = b; | |
| 644 | + b = nil; | |
| 645 | + s->in.mid++; | |
| 646 | + qunlock(&s->in.ctlq); | |
| 647 | + poperror(); | |
| 648 | + } | |
| 649 | + | |
| 650 | + /* return at most what was asked for */ | |
| 651 | + b = qtake(&s->processed, n, 0); | |
| 652 | + | |
| 653 | + qunlock(&s->in.q); | |
| 654 | + poperror(); | |
| 655 | + | |
| 656 | + return b; | |
| 657 | +} | |
| 658 | + | |
| 659 | +static long | |
| 660 | +sslread(Chan *c, void *a, long n, vlong off) | |
| 661 | +{ | |
| 662 | + Block * volatile b; | |
| 663 | + Block *nb; | |
| 664 | + uchar *va; | |
| 665 | + int i; | |
| 666 | + char buf[128]; | |
| 667 | + ulong offset = off; | |
| 668 | + int ft; | |
| 669 | + | |
| 670 | + if(c->qid.type & QTDIR) | |
| 671 | + return devdirread(c, a, n, 0, 0, sslgen); | |
| 672 | + | |
| 673 | + ft = TYPE(c->qid); | |
| 674 | + switch(ft) { | |
| 675 | + default: | |
| 676 | + error(Ebadusefd); | |
| 677 | + case Qctl: | |
| 678 | + ft = CONV(c->qid); | |
| 679 | + sprint(buf, "%d", ft); | |
| 680 | + return readstr(offset, a, n, buf); | |
| 681 | + case Qdata: | |
| 682 | + b = sslbread(c, n, offset); | |
| 683 | + break; | |
| 684 | + case Qencalgs: | |
| 685 | + return readstr(offset, a, n, encalgs); | |
| 686 | + break; | |
| 687 | + case Qhashalgs: | |
| 688 | + return readstr(offset, a, n, hashalgs); | |
| 689 | + break; | |
| 690 | + } | |
| 691 | + | |
| 692 | + if(waserror()){ | |
| 693 | + freeblist(b); | |
| 694 | + nexterror(); | |
| 695 | + } | |
| 696 | + | |
| 697 | + n = 0; | |
| 698 | + va = a; | |
| 699 | + for(nb = b; nb; nb = nb->next){ | |
| 700 | + i = BLEN(nb); | |
| 701 | + memmove(va+n, nb->rp, i); | |
| 702 | + n += i; | |
| 703 | + } | |
| 704 | + | |
| 705 | + freeblist(b); | |
| 706 | + poperror(); | |
| 707 | + | |
| 708 | + return n; | |
| 709 | +} | |
| 710 | + | |
| 711 | +/* | |
| 712 | + * this algorithm doesn't have to be great since we're just | |
| 713 | + * trying to obscure the block fill | |
| 714 | + */ | |
| 715 | +static void | |
| 716 | +randfill(uchar *buf, int len) | |
| 717 | +{ | |
| 718 | + while(len-- > 0) | |
| 719 | + *buf++ = nrand(256); | |
| 720 | +} | |
| 721 | + | |
| 722 | +static long | |
| 723 | +sslbwrite(Chan *c, Block *b, ulong o) | |
| 724 | +{ | |
| 725 | + Dstate * volatile s; | |
| 726 | + long rv; | |
| 727 | + | |
| 728 | + USED(o); | |
| 729 | + s = dstate[CONV(c->qid)]; | |
| 730 | + if(s == nil) | |
| 731 | + panic("sslbwrite"); | |
| 732 | + | |
| 733 | + if(s->state == Sincomplete){ | |
| 734 | + freeb(b); | |
| 735 | + error(Ebadusefd); | |
| 736 | + } | |
| 737 | + | |
| 738 | + /* lock so split writes won't interleave */ | |
| 739 | + if(waserror()){ | |
| 740 | + qunlock(&s->out.q); | |
| 741 | + nexterror(); | |
| 742 | + } | |
| 743 | + qlock(&s->out.q); | |
| 744 | + | |
| 745 | + rv = sslput(s, b); | |
| 746 | + | |
| 747 | + poperror(); | |
| 748 | + qunlock(&s->out.q); | |
| 749 | + | |
| 750 | + return rv; | |
| 751 | +} | |
| 752 | + | |
| 753 | +/* | |
| 754 | + * use SSL record format, add in count, digest and/or encrypt. | |
| 755 | + * the write is interruptable. if it is interrupted, we'll | |
| 756 | + * get out of sync with the far side. not much we can do about | |
| 757 | + * it since we don't know if any bytes have been written. | |
| 758 | + */ | |
| 759 | +static long | |
| 760 | +sslput(Dstate *s, Block * volatile b) | |
| 761 | +{ | |
| 762 | + Block *nb; | |
| 763 | + int h, n, m, pad, rv; | |
| 764 | + uchar *p; | |
| 765 | + int offset; | |
| 766 | + | |
| 767 | + if(waserror()){ | |
| 768 | + if(b != nil) | |
744 more lines aren’t shown here.
This diff is large: its 28 lines aren’t shown here.
This diff is large: its 51 lines aren’t shown here.
This diff is large: its 51 lines aren’t shown here.
This diff is large: its 822 lines aren’t shown here.
This diff is large: its 378 lines aren’t shown here.
This diff is large: its 48 lines aren’t shown here.
This diff is large: its 134 lines aren’t shown here.
This diff is large: its 185 lines aren’t shown here.
This diff is large: its 114 lines aren’t shown here.
This diff is large: its 273 lines aren’t shown here.
This diff is large: its 191 lines aren’t shown here.
This diff is large: its 68 lines aren’t shown here.
This diff is large: its 1525 lines aren’t shown here.
This diff is large: its 95 lines aren’t shown here.
This diff is large: its 91 lines aren’t shown here.
This diff is large: its 40 lines aren’t shown here.
This diff is large: its 60 lines aren’t shown here.
This diff is large: its 91 lines aren’t shown here.
This diff is large: its 19 lines aren’t shown here.
This diff is large: its 171 lines aren’t shown here.
This diff is large: its 838 lines aren’t shown here.
This diff is large: its 1243 lines aren’t shown here.
This diff is large: its 33 lines aren’t shown here.
This diff is large: its 205 lines aren’t shown here.
Empty file added.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 28 lines aren’t shown here.
This diff is large: its 19 lines aren’t shown here.
This diff is large: its 602 lines aren’t shown here.
This diff is large: its 178 lines aren’t shown here.
This diff is large: its 29 lines aren’t shown here.
This diff is large: its 32 lines aren’t shown here.
This diff is large: its 26 lines aren’t shown here.
This diff is large: its 24 lines aren’t shown here.
This diff is large: its 29 lines aren’t shown here.
This diff is large: its 29 lines aren’t shown here.
This diff is large: its 29 lines aren’t shown here.
This diff is large: its 29 lines aren’t shown here.
This diff is large: its 28 lines aren’t shown here.
This diff is large: its 28 lines aren’t shown here.
This diff is large: its 26 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 30 lines aren’t shown here.
This diff is large: its 34 lines aren’t shown here.
This diff is large: its 369 lines aren’t shown here.
This diff is large: its 90 lines aren’t shown here.
This diff is large: its 82 lines aren’t shown here.
This diff is large: its 53 lines aren’t shown here.
This diff is large: its 96 lines aren’t shown here.
This diff is large: its 95 lines aren’t shown here.
This diff is large: its 316 lines aren’t shown here.
This diff is large: its 387 lines aren’t shown here.
This diff is large: its 69 lines aren’t shown here.
This diff is large: its 210 lines aren’t shown here.
This diff is large: its 38 lines aren’t shown here.
This diff is large: its 20 lines aren’t shown here.
This diff is large: its 49 lines aren’t shown here.
This diff is large: its 38 lines aren’t shown here.
This diff is large: its 20 lines aren’t shown here.
This diff is large: its 521 lines aren’t shown here.
This diff is large: its 47 lines aren’t shown here.
This diff is large: its 13 lines aren’t shown here.
This diff is large: its 235 lines aren’t shown here.
This diff is large: its 313 lines aren’t shown here.
This diff is large: its 194 lines aren’t shown here.
This diff is large: its 100 lines aren’t shown here.
This diff is large: its 86 lines aren’t shown here.
This diff is large: its 32 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 33 lines aren’t shown here.
This diff is large: its 248 lines aren’t shown here.
This diff is large: its 26 lines aren’t shown here.
This diff is large: its 12 lines aren’t shown here.
This diff is large: its 32 lines aren’t shown here.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 18 lines aren’t shown here.
This diff is large: its 38 lines aren’t shown here.
This diff is large: its 18 lines aren’t shown here.
This diff is large: its 19 lines aren’t shown here.
This diff is large: its 65 lines aren’t shown here.
This diff is large: its 84 lines aren’t shown here.
This diff is large: its 14 lines aren’t shown here.
This diff is large: its 91 lines aren’t shown here.
This diff is large: its 5 lines aren’t shown here.
This diff is large: its 56 lines aren’t shown here.
This diff is large: its 53 lines aren’t shown here.
This diff is large: its 19 lines aren’t shown here.
This diff is large: its 67 lines aren’t shown here.
This diff is large: its 50 lines aren’t shown here.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 45 lines aren’t shown here.
This diff is large: its 9 lines aren’t shown here.
This diff is large: its 32 lines aren’t shown here.
This diff is large: its 23 lines aren’t shown here.
This diff is large: its 163 lines aren’t shown here.
This diff is large: its 12 lines aren’t shown here.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 16 lines aren’t shown here.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 11 lines aren’t shown here.
This diff is large: its 21 lines aren’t shown here.
This diff is large: its 21 lines aren’t shown here.
This diff is large: its 14 lines aren’t shown here.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 18 lines aren’t shown here.
This diff is large: its 10 lines aren’t shown here.
This diff is large: its 18 lines aren’t shown here.
This diff is large: its 23 lines aren’t shown here.
This diff is large: its 19 lines aren’t shown here.
This diff is large: its 16 lines aren’t shown here.
This diff is large: its 30 lines aren’t shown here.
This diff is large: its 1139 lines aren’t shown here.
This diff is large: its 24 lines aren’t shown here.
This diff is large: its 71 lines aren’t shown here.
This diff is large: its 23 lines aren’t shown here.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 16 lines aren’t shown here.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 18 lines aren’t shown here.
This diff is large: its 533 lines aren’t shown here.
This diff is large: its 5 lines aren’t shown here.
This diff is large: its 94 lines aren’t shown here.
This diff is large: its 31 lines aren’t shown here.
This diff is large: its 52 lines aren’t shown here.
This diff is large: its 108 lines aren’t shown here.
This diff is large: its 18 lines aren’t shown here.
This diff is large: its 54 lines aren’t shown here.
This diff is large: its 111 lines aren’t shown here.
This diff is large: its 128 lines aren’t shown here.
This diff is large: its 52 lines aren’t shown here.
This diff is large: its 15 lines aren’t shown here.
This diff is large: its 22 lines aren’t shown here.
This diff is large: its 24 lines aren’t shown here.
This diff is large: its 27 lines aren’t shown here.
This diff is large: its 32 lines aren’t shown here.
This diff is large: its 31 lines aren’t shown here.
This diff is large: its 27 lines aren’t shown here.
This diff is large: its 35 lines aren’t shown here.
This diff is large: its 24 lines aren’t shown here.
This diff is large: its 71 lines aren’t shown here.
This diff is large: its 23 lines aren’t shown here.
This diff is large: its 25 lines aren’t shown here.
This diff is large: its 238 lines aren’t shown here.
This diff is large: its 207 lines aren’t shown here.
This diff is large: its 35 lines aren’t shown here.
This diff is large: its 78 lines aren’t shown here.
This diff is large: its 403 lines aren’t shown here.
This diff is large: its 24 lines aren’t shown here.
This diff is large: its 141 lines aren’t shown here.
This diff is large: its 262 lines aren’t shown here.
This diff is large: its 19 lines aren’t shown here.
This diff is large: its 26 lines aren’t shown here.
This diff is large: its 100 lines aren’t shown here.
This diff is large: its 34 lines aren’t shown here.
This diff is large: its 201 lines aren’t shown here.
This diff is large: its 10 lines aren’t shown here.
This diff is large: its 118 lines aren’t shown here.
This diff is large: its 63 lines aren’t shown here.
This diff is large: its 69 lines aren’t shown here.
This diff is large: its 321 lines aren’t shown here.
This diff is large: its 97 lines aren’t shown here.
This diff is large: its 69 lines aren’t shown here.
This diff is large: its 2500 lines aren’t shown here.
This diff is large: its 1005 lines aren’t shown here.
This diff is large: its 249 lines aren’t shown here.
This diff is large: its 524 lines aren’t shown here.
This diff is large: its 13 lines aren’t shown here.
This diff is large: its 13 lines aren’t shown here.
This diff is large: its 486 lines aren’t shown here.
This diff is large: its 73 lines aren’t shown here.
This diff is large: its 80 lines aren’t shown here.
This diff is large: its 28 lines aren’t shown here.
This diff is large: its 54 lines aren’t shown here.
This diff is large: its 25 lines aren’t shown here.
This diff is large: its 112 lines aren’t shown here.
This diff is large: its 69 lines aren’t shown here.
This diff is large: its 35 lines aren’t shown here.
This diff is large: its 20 lines aren’t shown here.
This diff is large: its 26 lines aren’t shown here.
This diff is large: its 184 lines aren’t shown here.
This diff is large: its 27 lines aren’t shown here.
This diff is large: its 193 lines aren’t shown here.
This diff is large: its 80 lines aren’t shown here.
This diff is large: its 113 lines aren’t shown here.
This diff is large: its 68 lines aren’t shown here.
This diff is large: its 68 lines aren’t shown here.
This diff is large: its 123 lines aren’t shown here.
This diff is large: its 56 lines aren’t shown here.
This diff is large: its 108 lines aren’t shown here.
This diff is large: its 36 lines aren’t shown here.
This diff is large: its 81 lines aren’t shown here.
This diff is large: its 70 lines aren’t shown here.
This diff is large: its 24 lines aren’t shown here.
This diff is large: its 53 lines aren’t shown here.
This diff is large: its 47 lines aren’t shown here.
This diff is large: its 41 lines aren’t shown here.
This diff is large: its 123 lines aren’t shown here.
This diff is large: its 55 lines aren’t shown here.
This diff is large: its 16 lines aren’t shown here.
This diff is large: its 30 lines aren’t shown here.
This diff is large: its 41 lines aren’t shown here.
This diff is large: its 55 lines aren’t shown here.
This diff is large: its 186 lines aren’t shown here.
This diff is large: its 29 lines aren’t shown here.
This diff is large: its 44 lines aren’t shown here.
This diff is large: its 113 lines aren’t shown here.
This diff is large: its 83 lines aren’t shown here.
This diff is large: its 87 lines aren’t shown here.
This diff is large: its 98 lines aren’t shown here.
This diff is large: its 194 lines aren’t shown here.
This diff is large: its 22 lines aren’t shown here.
This diff is large: its 47 lines aren’t shown here.
This diff is large: its 16 lines aren’t shown here.
This diff is large: its 157 lines aren’t shown here.
This diff is large: its 43 lines aren’t shown here.
This diff is large: its 41 lines aren’t shown here.
This diff is large: its 53 lines aren’t shown here.
This diff is large: its 58 lines aren’t shown here.
This diff is large: its 45 lines aren’t shown here.
This diff is large: its 55 lines aren’t shown here.
This diff is large: its 36 lines aren’t shown here.
This diff is large: its 50 lines aren’t shown here.
This diff is large: its 70 lines aren’t shown here.
This diff is large: its 36 lines aren’t shown here.
This diff is large: its 29 lines aren’t shown here.
This diff is large: its 104 lines aren’t shown here.
This diff is large: its 35 lines aren’t shown here.
This diff is large: its 4 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 206 lines aren’t shown here.
This diff is large: its 61 lines aren’t shown here.
This diff is large: its 1545 lines aren’t shown here.
This diff is large: its 580 lines aren’t shown here.
This diff is large: its 60 lines aren’t shown here.
This diff is large: its 481 lines aren’t shown here.
This diff is large: its 60 lines aren’t shown here.
This diff is large: its 49 lines aren’t shown here.
This diff is large: its 60 lines aren’t shown here.
This diff is large: its 49 lines aren’t shown here.
This diff is large: its 32 lines aren’t shown here.
This diff is large: its 70 lines aren’t shown here.
This diff is large: its 62 lines aren’t shown here.
This diff is large: its 98 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 53 lines aren’t shown here.
This diff is large: its 47 lines aren’t shown here.
This diff is large: its 68 lines aren’t shown here.
This diff is large: its 29 lines aren’t shown here.
This diff is large: its 39 lines aren’t shown here.
This diff is large: its 22 lines aren’t shown here.
This diff is large: its 18 lines aren’t shown here.
This diff is large: its 44 lines aren’t shown here.
This diff is large: its 35 lines aren’t shown here.
This diff is large: its 30 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 28 lines aren’t shown here.
This diff is large: its 63 lines aren’t shown here.
This diff is large: its 37 lines aren’t shown here.
This diff is large: its 58 lines aren’t shown here.
This diff is large: its 57 lines aren’t shown here.
This diff is large: its 20 lines aren’t shown here.
This diff is large: its 272 lines aren’t shown here.
This diff is large: its 32 lines aren’t shown here.
This diff is large: its 149 lines aren’t shown here.
This diff is large: its 268 lines aren’t shown here.
This diff is large: its 38 lines aren’t shown here.
This diff is large: its 56 lines aren’t shown here.
This diff is large: its 24 lines aren’t shown here.
This diff is large: its 3 lines aren’t shown here.
This diff is large: its 42 lines aren’t shown here.
This diff is large: its 16 lines aren’t shown here.
This diff is large: its 85 lines aren’t shown here.
Binary file not shown.
This diff is large: its 105 lines aren’t shown here.
This diff is large: its 51 lines aren’t shown here.
This diff is large: its 53 lines aren’t shown here.
This diff is large: its 38 lines aren’t shown here.
This diff is large: its 13 lines aren’t shown here.
This diff is large: its 62 lines aren’t shown here.
This diff is large: its 83 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 58 lines aren’t shown here.
This diff is large: its 128 lines aren’t shown here.
This diff is large: its 188 lines aren’t shown here.
This diff is large: its 39 lines aren’t shown here.
This diff is large: its 1005 lines aren’t shown here.
This diff is large: its 1040 lines aren’t shown here.
This diff is large: its 98 lines aren’t shown here.
This diff is large: its 2292 lines aren’t shown here.
This diff is large: its 2521 lines aren’t shown here.
This diff is large: its 127 lines aren’t shown here.
This diff is large: its 96 lines aren’t shown here.
This diff is large: its 55 lines aren’t shown here.
This diff is large: its 10 lines aren’t shown here.
This diff is large: its 51 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 9 lines aren’t shown here.
This diff is large: its 242 lines aren’t shown here.
This diff is large: its 215 lines aren’t shown here.
This diff is large: its 24 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 9 lines aren’t shown here.
This diff is large: its 43 lines aren’t shown here.
This diff is large: its 111 lines aren’t shown here.
This diff is large: its 17 lines aren’t shown here.
This diff is large: its 668 lines aren’t shown here.
This diff is large: its 9 lines aren’t shown here.
This diff is large: its 242 lines aren’t shown here.
This diff is large: its 11 lines aren’t shown here.
This diff is large: its 215 lines aren’t shown here.
This diff is large: its 23 lines aren’t shown here.