APE updates required to support latest Python 2.7 build. Notes: The following files should be removed or verified that they do note exist: /sys/include/ape/inttypes.h /sys/src/ape/lib/bsd/sethostent.c /sys/src/ape/lib/draw/libc.h /sys/src/ape/lib/mp/port/libc.h /sys/src/ape/lib/sec/port/9ape.c /sys/src/ape/lib/sec/port/libc.h /sys/src/ape/lib/sec/port/x509-ape.c Sun Feb 23 01:36:08 EST 2014 geoff wow, a lot of changes. Reference: /n/sources/patch/maybe/ape-updates Date: Fri Aug 23 08:30:01 CES 2013 Signed-off-by: jas@corpus-callosum.com Reviewed-by: geoff --- /386/include/ape/inttypes.h Thu Jan 1 00:00:00 1970 +++ /386/include/ape/inttypes.h Fri Aug 23 08:15:17 2013 @@ -0,0 +1,21 @@ +#ifndef _SUSV2_SOURCE +#error "inttypes.h is SUSV2" +#endif + +#ifndef _INTTYPES_H_ +#define _INTTYPES_H_ 1 + + +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +typedef long long int64_t; +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +typedef long intptr_t; +typedef unsigned long uintptr_t; + +#endif --- /arm/include/ape/inttypes.h Thu Jan 1 00:00:00 1970 +++ /arm/include/ape/inttypes.h Fri Aug 23 08:15:18 2013 @@ -0,0 +1,21 @@ +#ifndef _SUSV2_SOURCE +#error "inttypes.h is SUSV2" +#endif + +#ifndef _INTTYPES_H_ +#define _INTTYPES_H_ 1 + + +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +typedef long long int64_t; +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +typedef long intptr_t; +typedef unsigned long uintptr_t; + +#endif --- /mips/include/ape/inttypes.h Thu Jan 1 00:00:00 1970 +++ /mips/include/ape/inttypes.h Fri Aug 23 08:15:19 2013 @@ -0,0 +1,21 @@ +#ifndef _SUSV2_SOURCE +#error "inttypes.h is SUSV2" +#endif + +#ifndef _INTTYPES_H_ +#define _INTTYPES_H_ 1 + + +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +typedef long long int64_t; +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +typedef long intptr_t; +typedef unsigned long uintptr_t; + +#endif --- /sys/src/ape/lib/9/amd64/getcallerpc.s Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/9/amd64/getcallerpc.s Fri Aug 23 08:15:20 2013 @@ -0,0 +1,3 @@ +TEXT getcallerpc(SB), $0 + MOVQ -8(RARG), AX + RET --- /sys/src/ape/lib/9/amd64/getfcr.s Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/9/amd64/getfcr.s Fri Aug 23 08:15:20 2013 @@ -0,0 +1,38 @@ + +TEXT setfcr(SB), $4 + XORL $(0x3F<<7),RARG /* bits are cleared in csr to enable them */ + ANDL $0xFFC0, RARG /* just the fcr bits */ + WAIT /* is this needed? */ + STMXCSR 0(SP) + MOVL 0(SP), AX + ANDL $~0x3F, AX + ORL RARG, AX + MOVL AX, 0(SP) + LDMXCSR 0(SP) + RET + +TEXT getfcr(SB), $4 + WAIT + STMXCSR 0(SP) + MOVWLZX 0(SP), AX + ANDL $0xFFC0, AX + XORL $(0x3F<<7),AX + RET + +TEXT getfsr(SB), $4 + WAIT + STMXCSR 0(SP) + MOVL 0(SP), AX + ANDL $0x3F, AX + RET + +TEXT setfsr(SB), $4 + ANDL $0x3F, RARG + WAIT + STMXCSR 0(SP) + MOVL 0(SP), AX + ANDL $~0x3F, AX + ORL RARG, AX + MOVL AX, 0(SP) + LDMXCSR 0(SP) + RET --- /sys/src/ape/lib/9/nsec.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/9/nsec.c Fri Aug 23 08:15:21 2013 @@ -0,0 +1,32 @@ +#include +#include "libc.h" + +static uvlong border = 0x0001020304050607ull; + +static uvlong +getbe(uchar *t, int w) +{ + uint i; + uvlong r; + + r = 0; + for(i = 0; i < w; i++) + r = r<<8 | t[i]; + return r; +} + +vlong +nsec(void) +{ + uchar b[8]; + int fd; + vlong v; + + fd = _OPEN("/dev/bintime", OREAD); + if(fd != -1 && _PREAD(fd, b, 8, 0) == 8) + v = getbe(b, 8); + else + v = 0; + _CLOSE(fd); + return v; +} --- /sys/src/ape/lib/9/wait.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/9/wait.c Fri Aug 23 08:15:22 2013 @@ -0,0 +1,31 @@ +#include +#include "libc.h" + +Waitmsg* +wait(void) +{ + int n, l; + char buf[512], *fld[5]; + Waitmsg *w; + + n = _AWAIT(buf, sizeof buf-1); + if(n < 0) + return nil; + buf[n] = '\0'; + if(tokenize(buf, fld, nelem(fld)) != nelem(fld)){ + werrstr("couldn't parse wait message"); + return nil; + } + l = strlen(fld[4])+1; + w = malloc(sizeof(Waitmsg)+l); + if(w == nil) + return nil; + w->pid = atoi(fld[0]); + w->time[0] = atoi(fld[1]); + w->time[1] = atoi(fld[2]); + w->time[2] = atoi(fld[3]); + w->msg = (char*)&w[1]; + memmove(w->msg, fld[4], l); + return w; +} + --- /sys/src/ape/lib/ap/amd64/_seek.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/amd64/_seek.c Fri Aug 23 08:15:23 2013 @@ -0,0 +1,11 @@ +extern long __SEEK(long long*, int, long long, int); + +long long +_SEEK(int fd, long long o, int p) +{ + long long l; + + if(__SEEK(&l, fd, o, p) < 0) + l = -1; + return l; +} --- /sys/src/ape/lib/ap/amd64/cycles.s Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/amd64/cycles.s Fri Aug 23 08:15:24 2013 @@ -0,0 +1,5 @@ +TEXT _cycles(SB),1,$0 /* time stamp counter; cycles since power up */ + RDTSC + MOVL AX, 0(RARG) /* lo */ + MOVL DX, 4(RARG) /* hi */ + RET --- /sys/src/ape/lib/ap/amd64/lock.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/amd64/lock.c Fri Aug 23 08:15:24 2013 @@ -0,0 +1,26 @@ +#define _LOCK_EXTENSION +#include "../plan9/sys9.h" +#include + +int tas(int*); + +void +lock(Lock *lk) +{ + while(tas(&lk->val)) + _SLEEP(0); +} + +int +canlock(Lock *lk) +{ + if(tas(&lk->val)) + return 0; + return 1; +} + +void +unlock(Lock *lk) +{ + lk->val = 0; +} --- /sys/src/ape/lib/ap/amd64/main9.s Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/amd64/main9.s Fri Aug 23 08:15:25 2013 @@ -0,0 +1,12 @@ + TEXT _main(SB), 1, $(3*8) + + CALL _envsetup(SB) + MOVL inargc-8(FP), RARG + LEAQ inargv+0(FP), AX + MOVQ AX, 8(SP) + MOVQ environ(SB), AX + MOVQ AX, 16(SP) + CALL main(SB) + MOVQ AX, RARG + CALL exit(SB) + RET --- /sys/src/ape/lib/ap/amd64/main9p.s Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/amd64/main9p.s Fri Aug 23 08:15:26 2013 @@ -0,0 +1,45 @@ +#define NPRIVATES 16 + +GLOBL _tos(SB), $8 +GLOBL _privates(SB), $8 +GLOBL _nprivates(SB), $8 + +TEXT _mainp(SB), 1, $(3*8+NPRIVATES*8) + + /* _tos = arg */ + MOVQ AX, _tos(SB) + LEAQ 8(SP), AX + MOVQ AX, _privates(SB) + MOVQ $NPRIVATES, _nprivates(SB) + + /* _profmain(); */ + CALL _profmain(SB) + + /* _tos->prof.pp = _tos->prof.next; */ + MOVQ _tos+0(SB),DX + MOVQ 4(DX),CX + MOVQ CX,(DX) + + CALL _envsetup(SB) + + /* main(argc, argv, environ); */ + MOVL inargc-8(FP), RARG + LEAQ inargv+0(FP), AX + MOVQ AX, 8(SP) + MOVQ environ(SB), AX + MOVQ AX, 16(SP) + CALL main(SB) + +loop: + MOVL AX, RARG + CALL exit(SB) + MOVQ $_profin(SB), AX /* force loading of profile */ + MOVL $0, AX + JMP loop + +TEXT _savearg(SB), 1, $0 + RET + +TEXT _callpc(SB), 1, $0 + MOVQ 8(RARG), AX + RET --- /sys/src/ape/lib/ap/amd64/mkfile Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/amd64/mkfile Fri Aug 23 08:15:27 2013 @@ -0,0 +1,20 @@ +APE=/sys/src/ape +objtype=amd64 +<$APE/config +LIB=/$objtype/lib/ape/libap.a +OFILES=\ + _seek.$O\ + cycles.$O\ + lock.$O\ + main9.$O\ + main9p.$O\ + notetramp.$O\ + setjmp.$O\ + strchr.$O\ + strlen.$O\ + tas.$O\ + + +#include + +/* A stack to hold pcs when signals nest */ +#define MAXSIGSTACK 20 +typedef struct Pcstack Pcstack; +static struct Pcstack { + int sig; + void (*hdlr)(int, char*, Ureg*); + unsigned long long restorepc; + Ureg *u; +} pcstack[MAXSIGSTACK]; +static int nstack = 0; + +static void notecont(Ureg*, char*); + +void +_notetramp(int sig, void (*hdlr)(int, char*, Ureg*), Ureg *u) +{ + Pcstack *p; + + if(nstack >= MAXSIGSTACK) + _NOTED(1); /* nesting too deep; just do system default */ + p = &pcstack[nstack]; + p->restorepc = u->ip; + p->sig = sig; + p->hdlr = hdlr; + p->u = u; + nstack++; + u->ip = (unsigned long long) notecont; + _NOTED(2); /* NSAVE: clear note but hold state */ +} + +static void +notecont(Ureg *u, char *s) +{ + Pcstack *p; + void(*f)(int, char*, Ureg*); + + p = &pcstack[nstack-1]; + f = p->hdlr; + u->ip = p->restorepc; + nstack--; + (*f)(p->sig, s, u); + _NOTED(3); /* NRSTR */ +} + +#define JMPBUFPC 1 +#define JMPBUFSP 0 + +extern sigset_t _psigblocked; + +typedef struct { + sigset_t set; + sigset_t blocked; + unsigned long long jmpbuf[2]; +} sigjmp_buf_amd64; + +void +siglongjmp(sigjmp_buf j, int ret) +{ + struct Ureg *u; + sigjmp_buf_amd64 *jb; + + jb = (sigjmp_buf_amd64*)j; + + if(jb->set) + _psigblocked = jb->blocked; + if(nstack == 0 || pcstack[nstack-1].u->sp > jb->jmpbuf[JMPBUFSP]) + longjmp((void*)jb->jmpbuf, ret); + u = pcstack[nstack-1].u; + nstack--; + u->ax = ret; + if(ret == 0) + u->ax = 1; + u->ip = jb->jmpbuf[JMPBUFPC]; + u->sp = jb->jmpbuf[JMPBUFSP] + 8; + _NOTED(3); /* NRSTR */ +} --- /sys/src/ape/lib/ap/amd64/setjmp.s Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/amd64/setjmp.s Fri Aug 23 08:15:29 2013 @@ -0,0 +1,27 @@ +TEXT longjmp(SB), $0 + MOVL r+8(FP), AX + CMPL AX, $0 + JNE ok /* ansi: "longjmp(0) => longjmp(1)" */ + MOVL $1, AX /* bless their pointed heads */ +ok: + MOVQ 0(RARG), SP /* restore sp */ + MOVQ 8(RARG), BX /* put return pc on the stack */ + MOVQ BX, 0(SP) + RET + +TEXT setjmp(SB), $0 + MOVQ SP, 0(RARG) /* store sp */ + MOVQ 0(SP), BX /* store return pc */ + MOVQ BX, 8(RARG) + MOVL $0, AX /* return 0 */ + RET + +TEXT sigsetjmp(SB), $0 + MOVL savemask+8(FP), BX + MOVL BX, 0(RARG) + MOVL $_psigblocked(SB), 4(RARG) + MOVQ SP, 8(RARG) /* store sp */ + MOVQ 0(SP), BX /* store return pc */ + MOVQ BX, 16(RARG) + MOVL $0, AX /* return 0 */ + RET --- /sys/src/ape/lib/ap/amd64/strchr.s Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/amd64/strchr.s Fri Aug 23 08:15:29 2013 @@ -0,0 +1,38 @@ + TEXT strchr(SB), $0 + + MOVQ RARG, DI + MOVB c+8(FP), AX + CMPB AX, $0 + JEQ l2 /**/ + +/* + * char is not null + */ +l1: + MOVB (DI), BX + CMPB BX, $0 + JEQ ret0 + ADDQ $1, DI + CMPB AX, BX + JNE l1 + + MOVQ DI, AX + SUBQ $1, AX + RET + +/* + * char is null + */ +l2: + MOVQ $-1, CX + CLD + + REPN; SCASB + + MOVQ DI, AX + SUBQ $1, AX + RET + +ret0: + MOVQ $0, AX + RET --- /sys/src/ape/lib/ap/amd64/strlen.s Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/amd64/strlen.s Fri Aug 23 08:15:30 2013 @@ -0,0 +1,16 @@ + TEXT strlen(SB),$0 + + MOVL $0, AX + MOVQ $-1, CX + CLD +/* + * look for end of string + */ + + MOVQ RARG, DI + REPN; SCASB + + MOVQ DI, AX + SUBQ RARG, AX + SUBQ $1, AX + RET --- /sys/src/ape/lib/ap/amd64/tas.s Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/amd64/tas.s Fri Aug 23 08:15:31 2013 @@ -0,0 +1,5 @@ +TEXT tas(SB),$0 + + MOVL $0xdeadead,AX + XCHGL AX,(RARG) + RET --- /sys/src/ape/lib/ap/plan9/copysign.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/plan9/copysign.c Fri Aug 23 08:15:32 2013 @@ -0,0 +1,18 @@ +#include +#include +#define _RESEARCH_SOURCE +#include + +#define SIGN (1<<31) + +double +copysign(double x, double y) +{ + FPdbleword a, b; + + a.x = x; + b.x = y; + a.hi &= ~SIGN; + a.hi |= b.hi & SIGN; + return a.x; +} --- /sys/src/ape/lib/ap/stdio/_IO_newfile.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/ap/stdio/_IO_newfile.c Fri Aug 23 08:15:33 2013 @@ -0,0 +1,27 @@ +/* + * pANS stdio -- fopen + */ +#include "iolib.h" + +#define _PLAN9_SOURCE +#include + +FILE *_IO_newfile(void) +{ + static FILE *fx=0; + static Lock fl; + FILE *f; + int i; + + lock(&fl); + for(i=0; i= &_IO_stream[FOPEN_MAX]) fx=_IO_stream; + if(fx->state==CLOSED) + break; + } + f = fx; + unlock(&fl); + if(f->state!=CLOSED) + return NULL; + return f; +} --- /sys/src/ape/lib/auth/authsrv.h Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/auth/authsrv.h Fri Aug 23 08:15:33 2013 @@ -0,0 +1,18 @@ +enum +{ + ANAMELEN= 28, /* name max size in previous proto */ + AERRLEN= 64, /* errstr max size in previous proto */ + DOMLEN= 48, /* authentication domain name length */ + DESKEYLEN= 7, /* encrypt/decrypt des key length */ + CHALLEN= 8, /* plan9 sk1 challenge length */ + NETCHLEN= 16, /* max network challenge length (used in AS protocol) */ + CONFIGLEN= 14, + SECRETLEN= 32, /* secret max size */ + + KEYDBOFF= 8, /* bytes of random data at key file's start */ + OKEYDBLEN= ANAMELEN+DESKEYLEN+4+2, /* old key file entry length */ + KEYDBLEN= OKEYDBLEN+SECRETLEN, /* key file entry length */ + OMD5LEN= 16, +}; + +extern int passtokey(char*, char*); --- /sys/src/ape/lib/auth/fcall.h Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/auth/fcall.h Fri Aug 23 08:15:34 2013 @@ -0,0 +1,20 @@ +#define VERSION9P "9P2000" +#define MAXWELEM 16 + +#define GBIT8(p) ((p)[0]) +#define GBIT16(p) ((p)[0]|((p)[1]<<8)) +#define GBIT32(p) ((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)) +#define GBIT64(p) ((u32int)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)) |\ + ((vlong)((p)[4]|((p)[5]<<8)|((p)[6]<<16)|((p)[7]<<24)) << 32)) + +#define PBIT8(p,v) (p)[0]=(v) +#define PBIT16(p,v) (p)[0]=(v);(p)[1]=(v)>>8 +#define PBIT32(p,v) (p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24 +#define PBIT64(p,v) (p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24;\ + (p)[4]=(v)>>32;(p)[5]=(v)>>40;(p)[6]=(v)>>48;(p)[7]=(v)>>56 + +#define BIT8SZ 1 +#define BIT16SZ 2 +#define BIT32SZ 4 +#define BIT64SZ 8 +#define QIDSZ (BIT8SZ+BIT32SZ+BIT64SZ) --- /sys/src/ape/lib/auth/mkfile Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/auth/mkfile Fri Aug 23 08:15:35 2013 @@ -0,0 +1,39 @@ +APE=/sys/src/ape +<$APE/config + +LIB=/$objtype/lib/ape/libauth.a +OFILES=\ + amount.$O\ + amount_getkey.$O\ + attr.$O\ + auth_attr.$O\ + auth_challenge.$O\ + auth_chuid.$O\ + auth_getkey.$O\ + auth_getuserpasswd.$O\ + auth_proxy.$O\ + auth_respond.$O\ + auth_rpc.$O\ + auth_userpasswd.$O\ + auth_wep.$O\ + login.$O\ +# newns.$O\ +# noworld.$O\ + +HFILES=\ + /sys/include/ape/auth.h\ + /sys/src/libauth/authlocal.h\ + ../9/libc.h + +UPDATE=\ + mkfile\ + $HFILES\ + ${OFILES:%.$O=%.c}\ + ${LIB:/$objtype/%=/386/%}\ + + +#include +#include +#include +#include +#include +#include + +/* bsd extensions */ +#include +#include +#include +#include + +#include "priv.h" + +void +_sock_ntop(int af, const void *addr, char *ip, int nip, int *port) +{ + struct sockaddr_in *a; + struct sockaddr_in6 *a6; + + switch(af){ + default: + abort(); + case AF_INET: + a = (struct sockaddr_in*)addr; + if(port != nil) + *port = ntohs(a->sin_port); + if(ip != nil) + inet_ntop(af, &a->sin_addr, ip, nip); + break; + case AF_INET6: + a6 = (struct sockaddr_in6*)addr; + if(port != nil) + *port = ntohs(a6->sin6_port); + if(ip != nil) + inet_ntop(af, &a6->sin6_addr, ip, nip); + break; + } +} + --- /sys/src/ape/lib/bsd/gai_strerr.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/bsd/gai_strerr.c Fri Aug 23 08:15:39 2013 @@ -0,0 +1,31 @@ +#include +#include +#include + +#define nil ((void*)0) +#define nelem(a) (sizeof(a)/sizeof((a)[0])) + +char *gaitab[] = { +[-EAI_BADFLAGS] "bad flags", +[-EAI_NONAME] "authoratitive negative response", +[-EAI_AGAIN] "temporary lookup failure", +[-EAI_FAIL] "name resolution failure", +[-EAI_FAMILY] "family not supported", +[-EAI_SOCKTYPE] "ai_socktype not supported", +[-EAI_SERVICE] "srvname unsupported", +[-EAI_MEMORY] "no memory", +[-EAI_SYSTEM] "see errno", +[-EAI_OVERFLOW] "overflow", +}; + +const char* +gai_strerror(int error) +{ + unsigned int e; + + e = -error; + if(e <= nelem(gaitab) && gaitab[e] != nil) + return gaitab[e]; + return "bogus gai_strerror argument"; +} + --- /sys/src/ape/lib/bsd/getaddrinfo.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/bsd/getaddrinfo.c Fri Aug 23 08:15:40 2013 @@ -0,0 +1,360 @@ +#define _SUSV2_SOURCE +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +static const struct addrinfo defhints = { +.ai_flags = AI_ALL, +.ai_family = PF_UNSPEC, +.ai_socktype = 0, +.ai_protocol = 0, +}; + +#define nil ((void*)0) +#define nelem(a) (sizeof(a)/sizeof((a)[0])) + +static int +chkfamily(int f) +{ + switch(f){ + default: + return -1; + case PF_UNSPEC: + case PF_INET: + case PF_INET6: + return 0; + } +} + +static struct { + char *s; + int proto; + int type; +} sockttab[] = { + "tcp", IPPROTO_TCP, SOCK_STREAM, + "il", IPPROTO_RAW, SOCK_STREAM, + "udp", IPPROTO_UDP, SOCK_DGRAM, + "icmp", IPPROTO_ICMP, SOCK_RAW, + "icmpv6", IPPROTO_ICMP, SOCK_RAW, +}; + +typedef struct Storage Storage; +struct Storage { + struct addrinfo ai; + struct sockaddr sa; + char buf[64]; +}; + +#define Strround(s) ((strlen(s)+1)+7 & ~7) + +static int +copyout(Storage *storage, int ns, int totsz, struct addrinfo *hint, struct addrinfo **res) +{ + char *p; + unsigned char *m; + int i; + Storage *s; + struct addrinfo *ai; + struct sockaddr *sa; + + m = malloc(totsz); + if(m == nil) + return EAI_MEMORY; + memset(m, 0, totsz); + *res = (void*)m; + + for(i = 0; i < ns; i++){ + s = storage + i; + sa = &s->sa; + + ai = (struct addrinfo*)m; + m += sizeof *ai; + ai->ai_addr = (struct sockaddr*)m; + m += s->ai.ai_addrlen; + + ai->ai_addrlen = s->ai.ai_addrlen; + memmove(ai->ai_addr, sa, s->ai.ai_addrlen); + ai->ai_family = s->ai.ai_family; + ai->ai_flags = hint->ai_flags; + ai->ai_socktype = s->ai.ai_socktype; + ai->ai_protocol = s->ai.ai_protocol; + + if(hint->ai_flags & AI_CANONNAME){ + ai->ai_canonname =(char*)m; + p = s->buf; + m += Strround(p); + memcpy(ai->ai_canonname, p, strlen(p)); + } + + if(i+1 < ns) + ai->ai_next = (struct addrinfo*)m; + } + return 0; +} + +static int +canon(int fd, Storage *a, int ns, int *totsz, struct addrinfo *hint) +{ + char buf[128], *f[15], *p; + int i, j, n, best, diff; + Storage *s; + + for(i = 0; i < ns; i++){ + s = a+i; + + lseek(fd, 0, 0); + if(s->buf[0] != 0 && (hint->ai_flags & AI_PASSIVE) == 0) + snprintf(buf, sizeof buf, "!ipinfo ip=%s sys dom", s->buf); + else + snprintf(buf, sizeof buf, "!ipinfo sys dom"); + if(write(fd, buf, strlen(buf)) == -1) + return EAI_FAIL; + lseek(fd, 0, 0); + n = read(fd, buf, sizeof buf-1); + if(n <= 0) + continue; + buf[n] = 0; + + // n = tokenize(buf, f, nelem(f)); + p = buf; + best = -1; + for(j = 0; j < n; j++){ + f[j] = p; + p = strchr(f[j], ' '); + if(p != nil) + *p++ = 0; + + if(strncmp(f[j], "dom=", 4) == 0) + break; + if(best == 0) + if(strncmp(f[j], "sys=", 4) == 0) + best = i; + + if(p == nil) + break; + } + if(j == n && best != -1) + j = best; + while((read(fd, buf, sizeof buf)) > 0) + ; + + if(j != n){ + p = strchr(f[j], '=')+1; + diff = Strround(s->buf) - Strround(p); + memset(s->buf, 0, sizeof s->buf); + memcpy(s->buf, p, strlen(p)); + *totsz -= diff; + } + } + return 0; +} + +static int +docsquery(char *nettype, char *host, char *service, struct addrinfo *hint, struct addrinfo **res) +{ + char buf[128], *p, *q, *r, *net; + int i, fd, rv, n, ns, af, sz, totsz; + struct sockaddr_in *in; + struct sockaddr_in6 *in6; + Storage storage[6]; + + fd = open("/net/cs", O_RDWR); + if(fd < 0) + return EAI_FAIL; + + snprintf(buf, sizeof buf, "%s!%s!%s", nettype, host, service); + if(write(fd, buf, strlen(buf)) == -1){ + close(fd); + return EAI_FAIL; + } + + lseek(fd, 0, 0); + totsz = 0; + for(ns = 0; ns < nelem(storage);){ + n = read(fd, buf, sizeof buf - 1); + if(n < 1) + break; + buf[n] = 0; + if((p = strchr(buf, ' ')) == nil) + continue; + *p++ = 0; + + if(strstr(buf, "!fasttimeout") != nil) + continue; + if((q = strchr(p, '!')) == nil) + q = ""; + else + *q++ = 0; + + if(strcmp(host, "*") == 0){ + q = p; + if(hint->ai_family == AF_INET6) + p = "::"; + else + p = "0.0.0.0"; + } + if(strlen(p) >= sizeof storage[0].buf) + continue; + + /* wrong for passive, except for icmp6 */ + af = AF_INET; + if(strchr(p, ':') != nil) + af = AF_INET6; + + if(hint->ai_family != AF_UNSPEC && af != hint->ai_family) + continue; + + sz = 0; + memset(&storage[ns], 0, sizeof(storage[ns])); + if(hint->ai_flags & AI_CANONNAME){ + memcpy(storage[ns].buf, p, strlen(p)); + sz += Strround(p); + } + + storage[ns].ai.ai_socktype = SOCK_DGRAM; + net = "tcp"; + r = strrchr(buf, '/'); + if(r != nil && strcmp(r, "/clone") == 0){ + *r = 0; + r = strrchr(buf, '/'); + if(r != nil) + net = r+1; + } + for(i = 0; i < nelem(sockttab); i++) + if(strcmp(sockttab[i].s, net) == 0) + if(sockttab[i].proto != IPPROTO_RAW || hint->ai_protocol == IPPROTO_RAW){ + storage[ns].ai.ai_socktype = sockttab[i].type; + storage[ns].ai.ai_protocol = sockttab[i].proto; + break; + } + if(i == nelem(sockttab)) + continue; + + storage[ns].ai.ai_family = af; + switch(af){ + case AF_INET: + in = (struct sockaddr_in*)&storage[ns].sa; + in->sin_family = af; + in->sin_addr.s_addr = inet_addr(p); + in->sin_port = ntohs(atoi(q)); + storage[ns].ai.ai_addrlen = sizeof *in; + sz += sizeof *in; + break; + case AF_INET6: + storage[ns].ai.ai_family = af; + in6 = (struct sockaddr_in6*)&storage[ns].sa; + in6->sin6_family = af; + inet_pton(af, p, &in6->sin6_addr); + in6->sin6_port = ntohs(atoi(q)); + storage[ns].ai.ai_addrlen = sizeof *in6; + sz += sizeof *in6; + break; + } + + totsz += sz + sizeof(struct addrinfo); + ns++; + + /* hacky way to get udp */ + if(strcmp(nettype, "net") == 0 && hint->ai_protocol == 0) + if(ns < nelem(storage)){ + storage[ns] = storage[ns-1]; + storage[ns].ai.ai_protocol = IPPROTO_UDP; + totsz += sz + sizeof(struct addrinfo); + ns++; + } + } + + rv = 0; + if(hint->ai_flags & AI_CANONNAME) + rv = canon(fd, storage, ns, &totsz, hint); + close(fd); + + if(rv != 0) + return rv; + if(ns == 0) + return EAI_NONAME; + return copyout(storage, ns, totsz, hint, res); +} + +int +getaddrinfo(const char *node, const char *service, const struct addrinfo *hint0, struct addrinfo **res) +{ + char *nettype, *p; + int i; + struct addrinfo hint; + + *res = nil; + + if(node == nil && service == nil) + return EAI_BADFLAGS; + if(hint0 == nil) + hint = defhints; + else + hint = *hint0; + + if(hint.ai_flags & AI_NUMERICSERV){ + if(service == nil) + return EAI_BADFLAGS; + strtoul(service, &p, 0); + if(*p != 0) + return EAI_NONAME; + } + + if(chkfamily(hint.ai_family) == -1) + return EAI_FAMILY; + if(node != nil) + hint.ai_flags &= ~AI_PASSIVE; + + /* not passive and no host → loopback */ + if(node == nil && (hint.ai_flags & AI_PASSIVE) == 0){ + switch(hint.ai_family){ + case PF_UNSPEC: + hint.ai_family = AF_INET; + case PF_INET: + node = "127.1"; + break; + case PF_INET6: + node = "::1"; + break; + } + } + else if (node == nil) + node = "*"; + + nettype = "net"; + switch(hint.ai_socktype){ + for(i = 0; i < nelem(sockttab); i++) + if(sockttab[i].type == hint.ai_socktype) + nettype = sockttab[i].s; + } + if(strcmp(nettype, "net") != 0 && hint.ai_protocol != 0) + return EAI_BADFLAGS; + if(hint.ai_protocol != 0){ + for(i = 0; i < nelem(sockttab); i++) + if(sockttab[i].proto == hint.ai_protocol) + nettype = sockttab[i].s; + } + if(hint.ai_family == PF_INET6 && strcmp(nettype, "icmp") == 0) + nettype = "icmpv6"; + + if(node == nil || *node == 0) + node = "*"; + if(service == nil || *service == 0) + service = "0"; + + return docsquery(nettype, node, service, &hint, res); +} + +void +freeaddrinfo(struct addrinfo *ai) +{ + free(ai); +} --- /sys/src/ape/lib/bsd/getnameinfo.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/bsd/getnameinfo.c Fri Aug 23 08:15:41 2013 @@ -0,0 +1,165 @@ +#define _SUSV2_SOURCE +#define _C99_SNPRINTF_EXTENSION +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#define nil ((void*)0) + +static int +getport(char *trans, int port, char *srv, int srvlen) +{ + char buf[128], match[5], *p, *q; + int fd, r, n; + + r = EAI_FAIL; + fd = open("/net/cs", O_RDWR); + if(fd < 0) + return r; + snprintf(buf, sizeof buf, "!port=%d %s=*", port, trans); + snprintf(match, sizeof match, "%s=", trans); + if(write(fd, buf, strlen(buf)) == -1){ + close(fd); + return r; + } + + lseek(fd, 0, 0); + n = read(fd, buf, sizeof buf - 1); + if(n > 0){ + buf[n] = 0; + for(p = buf; p != nil; p = q){ + q = strchr(buf, ' '); + if(q != nil) + *q++ = 0; + if(strncmp(p, match, 4) == 0){ + r = snprintf(srv, srvlen, "%s", p+4); + break; + } + } + } + close(fd); + return r; +} + +static int +getname(int af, void *addr, char *host, long hostlen, int flags) +{ + char ipbuf[128], buf[128], *p, *q; + int fd, r, n; + + r = EAI_FAIL; + if(inet_ntop(af, addr, ipbuf, sizeof ipbuf) == nil) + return EAI_SYSTEM; + fd = open("/net/cs", O_RDWR); + if(fd < 0) + return r; + snprintf(buf, sizeof buf, "!ip=%s dom=*", ipbuf); + if(write(fd, buf, strlen(buf)) == -1){ + close(fd); + return r; + } + + lseek(fd, 0, 0); + n = read(fd, buf, sizeof buf - 1); + if(n > 0){ + buf[n] = 0; + for(p = buf; p != nil; p = q){ + q = strchr(buf, ' '); + if(q != nil) + *q++ = 0; + if(strncmp(p, "dom=", 4) == 0){ + r = snprintf(ipbuf, sizeof ipbuf, "%s", p+4); + break; + } + } + } + close(fd); + + if(r >= 0){ + if(flags & NI_NOFQDN){ + p = strchr(ipbuf, '.'); + if(p != nil) + *p = 0; + } + r = EAI_OVERFLOW; + if(snprintf(host, hostlen, "%s", ipbuf) >= 0) + r = 0; + } + return r; +} + +static int +afhinfo(int af, void *addr, int port, char *host, long hostlen, char *srv, long srvlen, int flags) +{ + char *trans; + int r; + + trans = "tcp"; + if(flags & NI_DGRAM) + trans = "udp"; + + if(flags & NI_NUMERICSERV || getport(trans, port, srv, srvlen) < 0) + snprintf(srv, srvlen, "%d", port); + + /* require name even if not returning it */ + if(flags & NI_NAMEREQD){ + r = getname(af, addr, host, hostlen, flags); + if(r < 0) + return r; + } + if(flags & NI_NUMERICHOST){ + if(inet_ntop(af, addr, host, hostlen) == nil) + return EAI_SYSTEM; + return 0; + } + if(getname(af, addr, host, hostlen, flags) == 0) + return 0; + return 0; +} + +int +getnameinfo(const struct sockaddr *sa, int len, char *host, long hostlen, char *srv, long srvlen, int flags) +{ + char fakehost[64], fakesrv[16]; + struct sockaddr_in *in; + struct sockaddr_in6 *in6; + + if(host != nil && hostlen != 0) + *host = 0; + else{ + host = fakehost; + hostlen = sizeof fakehost; + } + if(srv != nil && hostlen != 0) + *srv = 0; + else{ + srv = fakesrv; + srvlen = sizeof fakesrv; + } + + switch(sa->sa_family){ + default: + return EAI_SOCKTYPE; + case AF_INET: + if(len < sizeof *in) + return EAI_OVERFLOW; + in = (struct sockaddr_in*)sa; + return afhinfo(AF_INET, &in->sin_addr, ntohs(in->sin_port), + host, hostlen, srv, srvlen, flags); + case AF_INET6: + if(len < sizeof *in6) + return EAI_OVERFLOW; + in6 = (struct sockaddr_in6*)sa; + return afhinfo(AF_INET6, &in6->sin6_addr, ntohs(in6->sin6_port), + host, hostlen, srv, srvlen, flags); + } +} --- /sys/src/ape/lib/bsd/herror.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/bsd/herror.c Fri Aug 23 08:15:42 2013 @@ -0,0 +1,46 @@ +/* posix */ +#include +#include +#include +#include +#include +#include + +/* bsd extensions */ +#include +#include +//#include + +#include "priv.h" + +int h_errno; + +static const char *hetab[] = { +[HOST_NOT_FOUND] "authoritative answer host not found", +[TRY_AGAIN] "non-authoritive host not found", +[NO_RECOVERY] "non recoverable error", +[NO_DATA] "valid name, no data record of requested type" +}; + +static const char* +getmsg(unsigned int e) +{ + const char *p; + + if(e > nelem(hetab) || (p = hetab[e]) == nil) + p = "unknown error"; + return p; +} + +void +herror(const char *s) +{ + fprintf(stderr, "%s: %s", s, getmsg(h_errno)); +} + + +const char* +hstrerror(int err) +{ + return getmsg(err); +} --- /sys/src/ape/lib/bsd/inet_ntop.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/bsd/inet_ntop.c Fri Aug 23 08:15:42 2013 @@ -0,0 +1,92 @@ +#define _SUSV2_SOURCE +#define _C99_SNPRINTF_EXTENSION +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#define nil ((void*)0) + +const char* +inet_ntop(int af, const void *src, char *dst, int size) +{ + char map[16/2], buf[32], *c; + int d, j, n, run, srun, maxrun, maxsrun; + uint8_t *u; + uint32_t i; + struct in_addr *ia; + struct in6_addr *ia6; + + switch(af){ + default: + errno = EAFNOSUPPORT; + return nil; + case AF_INET: + ia = (struct in_addr*)src; + i = ia->s_addr; + i = ntohl(i); + n = snprintf(dst, size, "%d.%d.%d.%d", + i>>24, i>>16 & 0xff, i>>8 & 0xff, i & 0xff); + if(n == -1){ + errno = ENOSPC; + return nil; + } + return dst; + case AF_INET6: + ia6 = (struct in6_addr*)src; + u = ia6->s6_addr; + + srun = run = 0; + maxrun = maxsrun = 0; + for(i = 0; i < 16; i += 2){ + if((u[i]|u[i+1]) == 0){ + map[i/2] = 1; + if(run == 0) + srun = i/2; + run++; + }else{ + if(run > 0 && run > maxrun){ + maxrun = run; + maxsrun = srun; + } + srun = run = 0; + } + } + if(run > 0 && run > maxrun){ + maxrun = run; + maxsrun = srun; + } + + /* buf must be bigger than biggest address, else -1 return gets us */ + memset(buf, 0, sizeof buf); + j = 0; + c = ":"; + for(i = 0; i < 8;){ + if(map[i] && i == maxsrun){ + j += snprintf(buf+j, sizeof buf-j, "%s:", c); + c = ""; + i += maxrun; + }else{ + d = u[i*2]<<8 | u[i*2+1]; + c = i<7? ":": ""; + j += snprintf(buf+j, sizeof buf-j, "%x%s", d, c); + c = ""; + i++; + } + } + if(strlen(buf)+1 > size){ + errno = ENOSPC; + return nil; + } + memcpy(dst, buf, strlen(buf)+1); + return dst; + } +} --- /sys/src/ape/lib/bsd/inet_pton.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/bsd/inet_pton.c Fri Aug 23 08:15:43 2013 @@ -0,0 +1,128 @@ +#define _SUSV2_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#define nil ((void*)0) +typedef unsigned char uchar; + +int classnetbytes[] = {1, 1, 2, 3, }; + +static char* +parseip4(uchar *u, char *s) +{ + char *v; + int i, d, b, n; + + for(i = 0; i < 4; i++){ + v = s; + d = strtoul(s, &s, 0); + if(d > 255) + return nil; + u[i] = d; + if(*s == '.') + s++; + else if(s == v) + break; + } + if(i < 4 && i > (b = classnetbytes[u[0]>>6])){ + n = i - b; + memmove(u+4-n, u+b, n); + memset(u+b, 0, 4-(b+n)); + i = 4; + } + if(i != 4) + return nil; + return s; +} + +static char* +parseip6(uchar *u, char *s) +{ + char *v; + int i, d, cc, is4; + + is4 = 1; + cc = -1; + for(i = 0; i < 16;){ + v = s; + d = strtoul(s, &s, 16); + switch(*s){ + case '.': + if(i + 4 > 16) + return nil; + s = parseip4(u+i, v); + if(s == nil) + return nil; + i += 4; + break; + case ':': + is4 = 0; + s++; + default: + if(d > 0xffff) + return nil; + u[i++] = d>>8; + u[i++] = d; + if(*s == ':'){ + if(cc != -1) + return nil; + cc = i; + s++; + } + if(s == v) + i -= 2; + break; + } + if(s == v) + break; + } + if(is4 && i == 4){ + memmove(u+12, u, 4); + memset(u, 0, 4); + memset(u+10, 0xff, 2); + } + else if(cc != -1 && i < 16){ + memmove(u+cc+(16-i), u+cc, i-cc); + memset(u+cc, 0, 16-i); + } + else if(i != 16) + return nil; + return s; +} + +int +inet_pton(int af, const char *src, void *dst) +{ + uchar u[16]; + struct in_addr *ia; + struct in6_addr *ia6; + + memset(u, 0, sizeof u); + switch(af){ + default: + errno = EAFNOSUPPORT; + return -1; + case AF_INET: + if(parseip4(u, src) == nil) + return 0; + ia = (struct in_addr*)dst; + memmove(&ia->s_addr, u, 4); + return 1; + case AF_INET6: + if(parseip6(u, src) == nil) + return 0; + ia6 = (struct in6_addr*)dst; + memmove(ia6->s6_addr, u, 16); + return 1; + } +} --- /sys/src/ape/lib/bsd/ip6const.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/bsd/ip6const.c Fri Aug 23 08:15:44 2013 @@ -0,0 +1,5 @@ +#include +#include + +const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT; +const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT; --- /sys/src/ape/lib/utf/getfields.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/utf/getfields.c Fri Aug 23 08:15:45 2013 @@ -0,0 +1,37 @@ +#include +#include + +int +getfields(char *str, char **args, int max, int mflag, char *set) +{ + Rune r; + int nr, intok, narg; + + if(max <= 0) + return 0; + + narg = 0; + args[narg] = str; + if(!mflag) + narg++; + intok = 0; + for(;; str += nr) { + nr = chartorune(&r, str); + if(r == 0) + break; + if(utfrune(set, r)) { + if(narg >= max) + break; + *str = 0; + intok = 0; + args[narg] = str + nr; + if(!mflag) + narg++; + } else { + if(!intok && mflag) + narg++; + intok = 1; + } + } + return narg; +} --- /sys/src/ape/lib/utf/gettokens.c Thu Jan 1 00:00:00 1970 +++ /sys/src/ape/lib/utf/gettokens.c Fri Aug 23 08:15:46 2013 @@ -0,0 +1,50 @@ +#include +#include + +static char* +etoken(char *t, char *sep) +{ + int quoting; + + /* move to end of next token */ + quoting = 0; + while(*t!='\0' && (quoting || utfrune(sep, *t)==nil)){ + if(*t != '\''){ + t++; + continue; + } + /* *t is a quote */ + if(!quoting){ + quoting = 1; + t++; + continue; + } + /* quoting and we're on a quote */ + if(t[1] != '\''){ + /* end of quoted section; absorb closing quote */ + t++; + quoting = 0; + continue; + } + /* doubled quote; fold one quote into two */ + t += 2; + } + return t; +} + +int +gettokens(char *s, char **args, int maxargs, char *sep) +{ + int nargs; + + for(nargs=0; nargs #endif + +int gethostname(char *, size_t); #ifdef __cplusplus } --- /sys/include/ape/utf.h Fri Aug 23 08:16:11 2013 +++ /sys/include/ape/utf.h Fri Aug 23 08:16:10 2013 @@ -55,6 +55,10 @@ extern int istitlerune(Rune); extern int isupperrune(Rune); +extern void rerrstr(char*, unsigned int); +extern int getfields(char*, char**, int, int, char*); +extern int gettokens(char *, char **, int, char *); + #if defined(__cplusplus) } #endif --- /sys/src/ape/lib/9/libc.h Fri Aug 23 08:16:13 2013 +++ /sys/src/ape/lib/9/libc.h Fri Aug 23 08:16:12 2013 @@ -1,3 +1,6 @@ +#ifndef _LIBC_H_ +#define _LIBC_H_ 1 + #define _LOCK_EXTENSION #define _QLOCK_EXTENSION #define _BSD_EXTENSION @@ -89,10 +92,10 @@ extern long _PWRITE(int, void*, long, long long); extern long _READ(int, void*, long); extern int _REMOVE(const char*); -extern int _RENDEZVOUS(unsigned long, unsigned long); +extern void* _RENDEZVOUS(void*, void*); extern int _RFORK(int); -extern int _SEGATTACH(int, char*, void*, unsigned long); -extern int _SEGBRK(void*, void*); +extern void* _SEGATTACH(int, char*, void*, unsigned long); +extern void* _SEGBRK(void*, void*); extern int _SEGDETACH(void*); extern int _SEGFLUSH(void*, unsigned long); extern int _SEGFREE(void*, unsigned long); @@ -102,39 +105,54 @@ extern Waitmsg* _WAIT(void); extern long _WRITE(int, const void*, long); extern int _WSTAT(const char*, unsigned char*, int); -extern void *_MALLOCZ(int, int); -extern int _WERRSTR(char*, ...); extern long _READN(int, void*, long); extern int _IOUNIT(int); +extern void *_MALLOCZ(int, int); /* not a syscall */ + #define dirstat _dirstat #define dirfstat _dirfstat #define OREAD 0 #define OWRITE 1 #define ORDWR 2 -#define OCEXEC 32 +#define OEXEC 3 /* execute, == read but check execute permission */ +#define OTRUNC 16 /* or'ed in (except for exec), truncate file first */ +#define OCEXEC 32 /* or'ed in, close on exec */ +#define ORCLOSE 64 /* or'ed in, remove on close */ +#define OEXCL 0x1000 /* or'ed in, exclusive use (create only) */ #define AREAD 4 #define AWRITE 2 #define AEXEC 1 #define AEXIST 0 +#ifdef thisisallgoingtoendintears #define open _OPEN #define close _CLOSE #define read _READ #define write _WRITE -#define _exits(s) _exit(s && *(char*)s ? 1 : 0) -#define exits(s) exit(s && *(char*)s ? 1 : 0) #define create _CREATE #define pread _PREAD +#define seek _SEEK +#endif + +/* we don't have fauth(), so let this slide */ +#define seek(fd, off, dir) lseek(fd, off, dir) +#define fauth _FAUTH +/* neither iounit */ +#define iounit _IOUNIT +#define wait _WAIT + +#define create(file, omode, perm) open(file, (omode) |O_CREAT | O_TRUNC, perm) #define readn _READN #define mallocz _MALLOCZ -#define iounit _IOUNIT +#define _exits(s) _exit(s && *(char*)s ? 1 : 0) +#define exits(s) exit(s && *(char*)s ? 1 : 0) /* assume being called as in event.c */ #define postnote(x, pid, msg) kill(pid, SIGTERM) -#define atnotify(x, y) signal(SIGTERM, ekill) +#define atnotify(x, y) signal(SIGTERM, NULL) #define ERRMAX 128 @@ -151,10 +169,14 @@ int enc32(char *, int, uchar *, int); int dec64(uchar *, int, char *, int); int enc64(char *, int, uchar *, int); +int decrypt(void*, void*, int); +int encrypt(void*, void*, int); extern vlong nsec(void); extern void sysfatal(char*, ...); extern ulong truerand(void); /* uses /dev/random */ -extern int getfields(char*, char**, int, int, char*); + +#endif /* _LIBC_H_ */ + --- /sys/src/ape/lib/9/mkfile Fri Aug 23 08:16:16 2013 +++ /sys/src/ape/lib/9/mkfile Fri Aug 23 08:16:15 2013 @@ -3,10 +3,12 @@ LIB=/$objtype/lib/ape/lib9.a OFILES=errstr.$O\ - bind.$O\ +# bind.$O\ + crypt.$O\ getcallerpc.$O\ getfcr.$O\ mount.$O\ + nsec.$O\ rendezvous.$O\ rfork.$O\ segattach.$O\ @@ -21,10 +23,11 @@ u32.$O\ u64.$O\ unmount.$O\ +# wait.$O\ -extern unsigned long _RENDEZVOUS(unsigned long, unsigned long); +extern void* _RENDEZVOUS(void*, void*); -unsigned long -rendezvous(unsigned long tag, unsigned long value) +void* +rendezvous(void* tag, void* value) { return _RENDEZVOUS(tag, value); } --- /sys/src/ape/lib/9/segattach.c Fri Aug 23 08:16:19 2013 +++ /sys/src/ape/lib/9/segattach.c Fri Aug 23 08:16:18 2013 @@ -1,8 +1,8 @@ #include -extern int _SEGATTACH(int, char*, void*, unsigned long); +extern void* _SEGATTACH(int, char*, void*, unsigned long); -int +void* segattach(int attr, char *class, void *va, unsigned long len) { return _SEGATTACH(attr, class, va, len); --- /sys/src/ape/lib/9/segbrk.c Fri Aug 23 08:16:21 2013 +++ /sys/src/ape/lib/9/segbrk.c Fri Aug 23 08:16:20 2013 @@ -2,7 +2,7 @@ extern int _SEGBRK(void*, void*); -int +void* segbrk(void *saddr, void *addr) { return _SEGBRK(saddr, addr); --- /sys/src/ape/lib/ap/386/mkfile Fri Aug 23 08:16:24 2013 +++ /sys/src/ape/lib/ap/386/mkfile Fri Aug 23 08:16:23 2013 @@ -23,5 +23,5 @@ 0) { if(*sp++ == c) - return sp-1; + return (void*)(sp-1); n--; } return 0; --- /sys/src/ape/lib/ap/gen/memcmp.c Fri Aug 23 08:16:30 2013 +++ /sys/src/ape/lib/ap/gen/memcmp.c Fri Aug 23 08:16:29 2013 @@ -3,7 +3,7 @@ int memcmp(const void *a1, const void *a2, size_t n) { - char *s1, *s2; + const char *s1, *s2; unsigned c1, c2; s1 = a1; --- /sys/src/ape/lib/ap/gen/memmove.c Fri Aug 23 08:16:32 2013 +++ /sys/src/ape/lib/ap/gen/memmove.c Fri Aug 23 08:16:31 2013 @@ -11,7 +11,7 @@ if(a1 > a2) goto back; s1 = a1; - s2 = a2; + s2 = (char*)a2; while(n > 0) { *s1++ = *s2++; n--; --- /sys/src/ape/lib/ap/gen/mkfile Fri Aug 23 08:16:35 2013 +++ /sys/src/ape/lib/ap/gen/mkfile Fri Aug 23 08:16:34 2013 @@ -61,4 +61,4 @@ +#include #define SWAPINIT(a, es) swaptype = \ - (a - (char*) 0) % sizeof(long) || es % sizeof(long) ? 2 : \ + ((uintptr_t)a - 0) % sizeof(long) || es % sizeof(long) ? 2 : \ es == sizeof(long) ? 0 : 1; #define swapcode(TYPE, parmi, parmj, n) { \ long i = (n) / (int) sizeof(TYPE); \ - register TYPE *pi = (TYPE *) (parmi); \ - register TYPE *pj = (TYPE *) (parmj); \ + TYPE *pi = (TYPE *) (parmi); \ + TYPE *pj = (TYPE *) (parmj); \ do { \ - register TYPE t = *pi; \ + TYPE t = *pi; \ *pi++ = *pj; \ *pj++ = t; \ } while (--i > 0); \ --- /sys/src/ape/lib/ap/gen/rand.c Fri Aug 23 08:16:39 2013 +++ /sys/src/ape/lib/ap/gen/rand.c Fri Aug 23 08:16:38 2013 @@ -27,8 +27,8 @@ rng_tap = rng_vec; rng_feed = rng_vec+LEN-TAP; seed = seed%M; - if(0 && seed < 0) /* seed is unsigned */ - seed += M; +// if(seed < 0) +// seed += M; if(seed == 0) seed = 89482311; x = seed; --- /sys/src/ape/lib/ap/gen/strcspn.c Fri Aug 23 08:16:41 2013 +++ /sys/src/ape/lib/ap/gen/strcspn.c Fri Aug 23 08:16:40 2013 @@ -5,7 +5,8 @@ size_t strcspn(const char *s, const char *b) { - char map[N], *os; + char map[N]; + const char *os; memset(map, 0, N); for(;;) { @@ -13,7 +14,7 @@ if(*b++ == 0) break; } - os = (char *)s; + os = s; while(map[*(unsigned char*)s++] == 0) ; return s - os - 1; --- /sys/src/ape/lib/ap/gen/strrchr.c Fri Aug 23 08:16:43 2013 +++ /sys/src/ape/lib/ap/gen/strrchr.c Fri Aug 23 08:16:42 2013 @@ -3,12 +3,12 @@ char* strrchr(const char *s, int c) { - char *r; + const char *r; if(c == 0) return strchr(s, 0); r = 0; while(s = strchr(s, c)) - r = (char *)s++; - return r; + r = s++; + return (char*)r; } --- /sys/src/ape/lib/ap/gen/strspn.c Fri Aug 23 08:16:45 2013 +++ /sys/src/ape/lib/ap/gen/strspn.c Fri Aug 23 08:16:43 2013 @@ -5,12 +5,13 @@ size_t strspn(const char *s, const char *b) { - char map[N], *os; + char map[N]; + const char *os; memset(map, 0, N); while(*b) map[*(unsigned char *)b++] = 1; - os = (char *)s; + os = s; while(map[*(unsigned char *)s++]) ; return s - os - 1; --- /sys/src/ape/lib/ap/math/mkfile Fri Aug 23 08:16:48 2013 +++ /sys/src/ape/lib/ap/math/mkfile Fri Aug 23 08:16:46 2013 @@ -24,4 +24,4 @@ = max) - break; - *str = 0; - intok = 0; - args[narg] = str + nr; - if(!mflag) - narg++; - } else { - if(!intok && mflag) - narg++; - intok = 1; - } - } - return narg; -} int _IOUNIT(int fd) { @@ -60,7 +25,7 @@ if(i <= 0) return 0; buf[i] = '\0'; - if(getfields(buf, args, 10, 1) != 10) + if(getfields(buf, args, 10, 1, " \t") != 10) return 0; return atoi(args[7]); } --- /sys/src/ape/lib/ap/plan9/_buf.c Fri Aug 23 08:16:57 2013 +++ /sys/src/ape/lib/ap/plan9/_buf.c Fri Aug 23 08:16:56 2013 @@ -11,6 +11,7 @@ #include #include #include +#include #include "sys9.h" typedef struct Muxseg { @@ -23,7 +24,6 @@ Muxbuf bufs[INITBUFS]; /* can grow, via segbrk() */ } Muxseg; -#define MUXADDR ((void*)0x6000000) static Muxseg *mux = 0; /* shared memory segment */ /* _muxsid and _killmuxsid are known in libbsd's listen.c */ @@ -57,8 +57,8 @@ if(mux == 0){ _RFORK(RFREND); - mux = (Muxseg*)_SEGATTACH(0, "shared", MUXADDR, sizeof(Muxseg)); - if((long)mux == -1){ + mux = (Muxseg*)_SEGATTACH(0, "shared", 0, sizeof(Muxseg)); + if(mux == (void*)-1){ _syserrno(); return -1; } @@ -72,7 +72,7 @@ lock(&mux->lock); slot = mux->curfds++; if(mux->curfds > INITBUFS) { - if(_SEGBRK(mux, mux->bufs+mux->curfds) < 0){ + if(_SEGBRK(mux, mux->bufs+mux->curfds) == (void*)-1){ _syserrno(); unlock(&mux->lock); return -1; @@ -99,7 +99,7 @@ for(i=0; ibuf = b; f->flags |= FD_BUFFERED; unlock(&mux->lock); - _muxsid = _RENDEZVOUS(0, 0); + _muxsid = (uintptr_t)_RENDEZVOUS((void*)0x101, 0); /* leave fd open in parent so system doesn't reuse it */ return 0; } @@ -152,7 +152,7 @@ /* sleep until there's room */ b->roomwait = 1; unlock(&mux->lock); - _RENDEZVOUS((unsigned long)&b->roomwait, 0); + _RENDEZVOUS(&b->roomwait, 0); } } else unlock(&mux->lock); @@ -174,15 +174,15 @@ if(mux->selwait && FD_ISSET(fd, &mux->ewant)) { mux->selwait = 0; unlock(&mux->lock); - _RENDEZVOUS((unsigned long)&mux->selwait, fd); + _RENDEZVOUS(&mux->selwait, (void*)fd); } else if(b->datawait) { b->datawait = 0; unlock(&mux->lock); - _RENDEZVOUS((unsigned long)&b->datawait, 0); + _RENDEZVOUS(&b->datawait, 0); } else if(mux->selwait && FD_ISSET(fd, &mux->rwant)) { mux->selwait = 0; unlock(&mux->lock); - _RENDEZVOUS((unsigned long)&mux->selwait, fd); + _RENDEZVOUS(&mux->selwait, (void*)fd); } else unlock(&mux->lock); _exit(0); @@ -195,12 +195,12 @@ b->datawait = 0; unlock(&mux->lock); /* wake up _bufreading process */ - _RENDEZVOUS((unsigned long)&b->datawait, 0); + _RENDEZVOUS(&b->datawait, 0); } else if(mux->selwait && FD_ISSET(fd, &mux->rwant)) { mux->selwait = 0; unlock(&mux->lock); /* wake up selecting process */ - _RENDEZVOUS((unsigned long)&mux->selwait, fd); + _RENDEZVOUS(&mux->selwait, (void*)fd); } else unlock(&mux->lock); } else @@ -237,7 +237,7 @@ /* sleep until there's data */ b->datawait = 1; unlock(&mux->lock); - _RENDEZVOUS((unsigned long)&b->datawait, 0); + _RENDEZVOUS(&b->datawait, 0); lock(&mux->lock); ngot = b->putnext - b->getnext; } @@ -255,7 +255,7 @@ b->roomwait = 0; unlock(&mux->lock); /* wake up copy process */ - _RENDEZVOUS((unsigned long)&b->roomwait, 0); + _RENDEZVOUS(&b->roomwait, 0); } else unlock(&mux->lock); return ngot; @@ -348,7 +348,7 @@ } mux->selwait = 1; unlock(&mux->lock); - fd = _RENDEZVOUS((unsigned long)&mux->selwait, 0); + fd = (uintptr_t)_RENDEZVOUS(&mux->selwait, 0); if(fd >= 0) { b = _fdinfo[fd].buf; if(FD_ISSET(fd, &mux->rwant)) { @@ -393,8 +393,9 @@ setpgid(getpid(), _muxsid); signal(SIGALRM, alarmed); for(i=0; iwaittime); if(timerreset) { @@ -405,7 +406,7 @@ mux->selwait = 0; mux->waittime = LONGWAIT; unlock(&mux->lock); - _RENDEZVOUS((unsigned long)&mux->selwait, -2); + _RENDEZVOUS(&mux->selwait, (void*)-2); } else { mux->waittime = LONGWAIT; unlock(&mux->lock); @@ -415,7 +416,8 @@ } atexit(_killtimerproc); /* parent process continues */ - _RENDEZVOUS(1, 0); + while(_RENDEZVOUS((void*)0x103, 0) == (void*)~0) + ; } static void @@ -454,7 +456,7 @@ } static int -copynotehandler(void *, char *) +copynotehandler(void*, char*) { if(_finishing) _finish(0, 0); --- /sys/src/ape/lib/ap/plan9/_envsetup.c Fri Aug 23 08:16:59 2013 +++ /sys/src/ape/lib/ap/plan9/_envsetup.c Fri Aug 23 08:16:58 2013 @@ -21,7 +21,6 @@ char **environ; int errno; unsigned long _clock; - static void fdsetup(char *, char *); static void sigsetup(char *, char *); @@ -32,48 +31,45 @@ void _envsetup(void) { - int dfd, fdinited, n, nd, m, i, j, f, nohandle, psize, cnt; - char *ps, *p; + int dfd; + int n, nd, m, i, j, f; + int psize, cnt; + int nohandle; + int fdinited; + char *ps, *p, *name; char **pp; - char name[NAME_MAX+5]; Dir *d9, *d9a; - static char **emptyenvp = 0; - environ = emptyenvp; /* pessimism */ nohandle = 0; fdinited = 0; cnt = 0; - strcpy(name, "#e"); - dfd = _OPEN(name, 0); - if(dfd < 0) + dfd = _OPEN("/env", 0); + if(dfd < 0) { + environ = malloc(sizeof(char**)); + *environ = NULL; return; - name[2] = '/'; + } ps = p = malloc(Envhunk); - if(p == 0) - return; psize = Envhunk; nd = _dirreadall(dfd, &d9a); _CLOSE(dfd); for(j=0; jname); - if(n >= sizeof name - 4) - continue; /* shouldn't be possible */ m = d9->length; i = p - ps; if(i+n+1+m+1 > psize) { psize += (n+m+2 < Envhunk)? Envhunk : n+m+2; ps = realloc(ps, psize); - if (ps == 0) { - free(d9a); - return; - } p = ps + i; } memcpy(p, d9->name, n); p[n] = '='; - strcpy(name+3, d9->name); + name = malloc(n+6); + strcpy(name, "/env/"); + strcpy(name+5, d9->name); f = _OPEN(name, O_RDONLY); + free(name); if(f < 0 || _READ(f, p+n+1, m) != m) m = 0; _CLOSE(f); @@ -96,10 +92,7 @@ free(d9a); if(!fdinited) _fdinit(0, 0); - pp = malloc((1+cnt)*sizeof(char *)); - if (pp == 0) - return; - environ = pp; + environ = pp = malloc((1+cnt)*sizeof(char *)); p = ps; for(i = 0; i < cnt; i++) { *pp++ = p; --- /sys/src/ape/lib/ap/plan9/_getpw.c Fri Aug 23 08:17:01 2013 +++ /sys/src/ape/lib/ap/plan9/_getpw.c Fri Aug 23 08:17:00 2013 @@ -61,7 +61,7 @@ } matchnum = (*pname == NULL); matched = 0; - mem = nil; + mem = (void*)0; /* try using memo */ for(i = 0; i +#include #include "sys9.h" char end[]; static char *bloc = { end }; -extern int _BRK_(void*); + +enum +{ + Round = 7 +}; char * brk(char *p) { - unsigned long n; + uintptr_t bl; - n = (unsigned long)p; - n += 3; - n &= ~3; - if(_BRK_((void*)n) < 0){ + bl = ((uintptr_t)p + Round) & ~Round; + if(_BRK_((void*)bl) < 0){ errno = ENOMEM; return (char *)-1; } - bloc = (char *)n; + bloc = (char*)bl; return 0; } void * sbrk(unsigned long n) { - n += 3; - n &= ~3; + uintptr_t bl; + + bl = ((uintptr_t)bloc + Round) & ~Round; if(_BRK_((void *)(bloc+n)) < 0){ errno = ENOMEM; return (void *)-1; } - bloc += n; - return (void *)(bloc-n); + bloc = (char*)bl + n; + return (void*)bl; } --- /sys/src/ape/lib/ap/plan9/execve.c Fri Aug 23 08:17:05 2013 +++ /sys/src/ape/lib/ap/plan9/execve.c Fri Aug 23 08:17:04 2013 @@ -57,7 +57,7 @@ * are ignored, in case the current value of the * variable ignored some. */ - f = _CREATE("#e/_sighdlr", OWRITE, 0666); + f = _CREATE("/env/_sighdlr", OWRITE, 0666); if(f >= 0){ ss = buf; for(i = 0; i <=MAXSIG && ss < &buf[sizeof(buf)]-5; i++) { @@ -70,16 +70,16 @@ _CLOSE(f); } if(envp){ - strcpy(nam, "#e/"); - for(e = (char **)envp; (ss = *e); e++) { + strcpy(nam, "/env/"); + for(e = (char**)envp; (ss = *e); e++) { se = strchr(ss, '='); if(!se || ss==se) continue; /* what is name? value? */ n = se-ss; - if(n >= sizeof(nam)-3) - n = sizeof(nam)-3-1; - memcpy(nam+3, ss, n); - nam[3+n] = 0; + if(n >= sizeof(nam)-5) + n = sizeof(nam)-(5 + 1); + memcpy(nam+5, ss, n); + nam[5+n] = 0; f = _CREATE(nam, OWRITE, 0666); if(f < 0) continue; --- /sys/src/ape/lib/ap/plan9/frexp.c Fri Aug 23 08:17:06 2013 +++ /sys/src/ape/lib/ap/plan9/frexp.c Fri Aug 23 08:17:05 2013 @@ -8,51 +8,36 @@ #define BIAS 1022L #define SIG 52 -typedef union -{ - double d; - struct - { -#ifdef IEEE_8087 - long ls; - long ms; -#else - long ms; - long ls; -#endif - }; -} Cheat; - double frexp(double d, int *ep) { - Cheat x, a; + FPdbleword x, a; *ep = 0; - /* order matters: only isNaN can operate on NaN */ if(isNaN(d) || isInf(d, 0) || d == 0) return d; - x.d = d; - a.d = fabs(d); - if((a.ms >> SHIFT) == 0){ /* normalize subnormal numbers */ - x.d = (double)(1ULL<> SHIFT) == 0){ + /* normalize subnormal numbers */ + x.x = (double)(1ULL<> SHIFT) & MASK) - BIAS; - x.ms &= ~(MASK << SHIFT); - x.ms |= BIAS << SHIFT; - return x.d; + *ep += ((x.hi >> SHIFT) & MASK) - BIAS; + x.hi &= ~(MASK << SHIFT); + x.hi |= BIAS << SHIFT; + return x.x; } double ldexp(double d, int e) { - Cheat x; + FPdbleword x; if(d == 0) return 0; - x.d = d; - e += (x.ms >> SHIFT) & MASK; + x.x = d; + e += (x.hi >> SHIFT) & MASK; if(e <= 0) return 0; if(e >= MASK){ @@ -61,28 +46,18 @@ return -HUGE_VAL; return HUGE_VAL; } - x.ms &= ~(MASK << SHIFT); - x.ms |= (long)e << SHIFT; - return x.d; + x.hi &= ~(MASK << SHIFT); + x.hi |= (long)e << SHIFT; + return x.x; } double modf(double d, double *ip) { double f; - Cheat x; + FPdbleword x; int e; - x.d = d; - e = (x.ms >> SHIFT) & MASK; - if(e == MASK){ - *ip = d; - if(x.ls != 0 || (x.ms & 0xfffffL) != 0) /* NaN */ - return d; - /* ±Inf */ - x.ms &= 0x80000000L; - return x.d; - } if(d < 1) { if(d < 0) { f = modf(-d, ip); @@ -92,13 +67,14 @@ *ip = 0; return d; } - e -= BIAS; + x.x = d; + e = ((x.hi >> SHIFT) & MASK) - BIAS; if(e <= SHIFT+1) { - x.ms &= ~(0x1fffffL >> e); - x.ls = 0; + x.hi &= ~(0x1fffffL >> e); + x.lo = 0; } else if(e <= SHIFT+33) - x.ls &= ~(0x7fffffffL >> (e-SHIFT-2)); - *ip = x.d; - return d - x.d; + x.lo &= ~(0x7fffffffL >> (e-SHIFT-2)); + *ip = x.x; + return d - x.x; } --- /sys/src/ape/lib/ap/plan9/fsync.c Fri Aug 23 08:17:08 2013 +++ /sys/src/ape/lib/ap/plan9/fsync.c Fri Aug 23 08:17:07 2013 @@ -3,8 +3,9 @@ #include int -fsync(int) +fsync(int fd) { + USED(fd); errno = EINVAL; return -1; } --- /sys/src/ape/lib/ap/plan9/getgroups.c Fri Aug 23 08:17:10 2013 +++ /sys/src/ape/lib/ap/plan9/getgroups.c Fri Aug 23 08:17:09 2013 @@ -3,8 +3,9 @@ #include int -getgroups(int, gid_t []) +getgroups(int gidsize, gid_t grouplist[]) { + USED(gidsize, grouplist); errno = EINVAL; return -1; } --- /sys/src/ape/lib/ap/plan9/lib.h Fri Aug 23 08:17:12 2013 +++ /sys/src/ape/lib/ap/plan9/lib.h Fri Aug 23 08:17:11 2013 @@ -8,8 +8,8 @@ /* mux buf for selecting (see _buf.c) */ enum { READMAX = 8192, /* read at most this much with _READ */ - PERFDMAX = 2*READMAX, /* stop _READing an fd when it has this much */ - INITBUFS = 4, /* allow enough room for this many PERFDMAX */ + PERFDMAX = 2*READMAX, /* stop _READing an fd when it has this much */ + INITBUFS = 90, /* allow enough room for this many PERFDMAX */ }; typedef struct Muxbuf { --- /sys/src/ape/lib/ap/plan9/malloc.c Fri Aug 23 08:17:14 2013 +++ /sys/src/ape/lib/ap/plan9/malloc.c Fri Aug 23 08:17:13 2013 @@ -2,6 +2,8 @@ #include #include +#include + typedef unsigned int uint; enum @@ -25,10 +27,11 @@ struct Arena { Bucket *btab[MAX2SIZE]; + Lock; }; static Arena arena; -#define datoff ((int)((Bucket*)0)->data) +#define datoff ((intptr_t)((Bucket*)0)->data) #define nil ((void*)0) extern void *sbrk(unsigned long); @@ -48,16 +51,19 @@ return nil; good: /* Allocate off this list */ + lock(&arena); bp = arena.btab[pow]; if(bp) { arena.btab[pow] = bp->next; + unlock(&arena); if(bp->magic != 0) abort(); bp->magic = MAGIC; - return bp->data; + return bp->data; } + size = sizeof(Bucket)+(1<next = (Bucket*)next; nbp->size = pow; nbp = nbp->next; @@ -81,9 +89,12 @@ } else { bp = sbrk(size); - if((intptr_t)bp == -1) + if((intptr_t)bp == -1){ + unlock(&arena); return nil; + } } + unlock(&arena); bp->size = pow; bp->magic = MAGIC; @@ -100,15 +111,17 @@ return; /* Find the start of the structure */ - bp = (Bucket*)((uint)ptr - datoff); + bp = (Bucket*)((intptr_t)ptr - datoff); if(bp->magic != MAGIC) abort(); bp->magic = 0; l = &arena.btab[bp->size]; + lock(&arena); bp->next = *l; *l = bp; + unlock(&arena); } void* @@ -122,7 +135,7 @@ return malloc(n); /* Find the start of the structure */ - bp = (Bucket*)((uint)ptr - datoff); + bp = (Bucket*)((intptr_t)ptr - datoff); if(bp->magic != MAGIC) abort(); --- /sys/src/ape/lib/ap/plan9/mkfile Fri Aug 23 08:17:18 2013 +++ /sys/src/ape/lib/ap/plan9/mkfile Fri Aug 23 08:17:17 2013 @@ -26,6 +26,7 @@ close.$O\ convM2D.$O\ convD2M.$O\ + copysign.$O\ creat.$O\ ctermid.$O\ ctime.$O\ @@ -105,6 +106,6 @@ +#include #include "sys9.h" int pause(void) { for(;;) - if(_SLEEP(1000*1000) < 0) + if(_SLEEP(1000*1000) < 0){ + errno = EINTR; return -1; + } } --- /sys/src/ape/lib/ap/plan9/profile.c Fri Aug 23 08:17:22 2013 +++ /sys/src/ape/lib/ap/plan9/profile.c Fri Aug 23 08:17:20 2013 @@ -18,6 +18,7 @@ typedef long long vlong; typedef unsigned long ulong; typedef unsigned long long uvlong; +typedef unsigned long uint; #include "/sys/include/tos.h" --- /sys/src/ape/lib/ap/plan9/qlock.c Fri Aug 23 08:17:24 2013 +++ /sys/src/ape/lib/ap/plan9/qlock.c Fri Aug 23 08:17:22 2013 @@ -73,7 +73,7 @@ unlock(&q->lock); /* wait */ - while((*_rendezvousp)((ulong)mp, 1) == ~0) + while((*_rendezvousp)(mp, (void*)1) == (void*)~0) ; mp->inuse = 0; } @@ -84,6 +84,8 @@ QLp *p; lock(&q->lock); + if (q->locked == 0) + abort(); p = q->head; if(p != nil){ /* wakeup head waiting process */ @@ -91,7 +93,7 @@ if(q->head == nil) q->tail = nil; unlock(&q->lock); - while((*_rendezvousp)((ulong)p, 0x12345) == ~0) + while((*_rendezvousp)(p, (void*)0x12345) == (void*)~0) ; return; } @@ -140,7 +142,7 @@ unlock(&q->lock); /* wait in kernel */ - while((*_rendezvousp)((ulong)mp, 1) == ~0) + while((*_rendezvousp)(mp, (void*)1) == (void*)~0) ; mp->inuse = 0; } @@ -183,7 +185,7 @@ unlock(&q->lock); /* wakeup waiter */ - while((*_rendezvousp)((ulong)p, 0) == ~0) + while((*_rendezvousp)(p, 0) == (void*)~0) ; } @@ -213,7 +215,7 @@ unlock(&q->lock); /* wait in kernel */ - while((*_rendezvousp)((ulong)mp, 1) == ~0) + while((*_rendezvousp)(mp, (void*)1) == (void*)~0) ; mp->inuse = 0; } @@ -252,7 +254,7 @@ if(q->head == nil) q->tail = nil; unlock(&q->lock); - while((*_rendezvousp)((ulong)p, 0) == ~0) + while((*_rendezvousp)(p, 0) == (void*)~0) ; return; } @@ -265,7 +267,7 @@ p = q->head; q->head = p->next; q->readers++; - while((*_rendezvousp)((ulong)p, 0) == ~0) + while((*_rendezvousp)(p, 0) == (void*)~0) ; } if(q->head == nil) @@ -303,7 +305,7 @@ if(r->l->head == nil) r->l->tail = nil; unlock(&r->l->lock); - while((*_rendezvousp)((ulong)t, 0x12345) == ~0) + while((*_rendezvousp)(t, (void*)0x12345) == (void*)~0) ; }else{ r->l->locked = 0; @@ -311,7 +313,7 @@ } /* wait for a wakeup */ - while((*_rendezvousp)((ulong)me, 1) == ~0) + while((*_rendezvousp)(me, (void*)1) == (void*)~0) ; me->inuse = 0; } --- /sys/src/ape/lib/ap/plan9/read.c Fri Aug 23 08:17:25 2013 +++ /sys/src/ape/lib/ap/plan9/read.c Fri Aug 23 08:17:24 2013 @@ -1,4 +1,5 @@ #include +#include #include #include #include "lib.h" @@ -7,12 +8,12 @@ #include ssize_t -read(int d, void *buf, size_t nbytes) +pread(int fd, void *buf, size_t nbytes, off_t offset) { int n, noblock, isbuf; Fdinfo *f; - if(d<0 || d>=OPEN_MAX || !(_fdinfo[d].flags&FD_ISOPEN)){ + if(fd<0 || fd>=OPEN_MAX || !((f = &_fdinfo[fd])->flags&FD_ISOPEN)){ errno = EBADF; return -1; } @@ -22,7 +23,6 @@ errno = EFAULT; return -1; } - f = &_fdinfo[d]; noblock = f->oflags&O_NONBLOCK; isbuf = f->flags&(FD_BUFFERED|FD_BUFFEREDX); if(noblock || isbuf){ @@ -31,16 +31,22 @@ return -1; } if(!isbuf) { - if(_startbuf(d) != 0) { + if(_startbuf(fd) != 0) { errno = EIO; return -1; } } - n = _readbuf(d, buf, nbytes, noblock); + n = _readbuf(fd, buf, nbytes, noblock); }else{ - n = _READ(d, buf, nbytes); + n = _PREAD(fd, buf, nbytes, offset); if(n < 0) _syserrno(); } return n; +} + +ssize_t +read(int fd, void *buf, size_t nbytes) +{ + return pread(fd, buf, nbytes, -1ll); } --- /sys/src/ape/lib/ap/plan9/rename.c Fri Aug 23 08:17:27 2013 +++ /sys/src/ape/lib/ap/plan9/rename.c Fri Aug 23 08:17:26 2013 @@ -11,7 +11,7 @@ rename(const char *from, const char *to) { int n; - char *f, *t; + const char *f, *t; Dir *d, nd; if(access(to, 0) >= 0){ @@ -31,13 +31,14 @@ } f = strrchr(from, '/'); t = strrchr(to, '/'); - f = f? f+1 : (char *)from; - t = t? t+1 : (char *)to; + f = f? f+1 : from; + t = t? t+1 : to; n = 0; if(f-from==t-to && strncmp(from, to, f-from)==0){ /* from and to are in same directory (we miss some cases) */ + strlen(t); _nulldir(&nd); - nd.name = t; + nd.name = (char*)t; if(_dirwstat(from, &nd) < 0){ _syserrno(); n = -1; --- /sys/src/ape/lib/ap/plan9/setgid.c Fri Aug 23 08:17:29 2013 +++ /sys/src/ape/lib/ap/plan9/setgid.c Fri Aug 23 08:17:28 2013 @@ -7,8 +7,9 @@ */ int -setgid(gid_t) +setgid(gid_t gid) { + USED(gid); errno = EPERM; return -1; } --- /sys/src/ape/lib/ap/plan9/setuid.c Fri Aug 23 08:17:31 2013 +++ /sys/src/ape/lib/ap/plan9/setuid.c Fri Aug 23 08:17:30 2013 @@ -7,8 +7,9 @@ */ int -setuid(uid_t) +setuid(uid_t uid) { + USED(uid); errno = EPERM; return -1; } --- /sys/src/ape/lib/ap/plan9/signal.c Fri Aug 23 08:17:33 2013 +++ /sys/src/ape/lib/ap/plan9/signal.c Fri Aug 23 08:17:32 2013 @@ -37,21 +37,23 @@ void (*_sighdlr[MAXSIG+1])(int, char*, Ureg*); /* 0 initialized: SIG_DFL */ -/* must match signal.h: extern void (*signal(int, void (*)()))(); */ -//void (*signal(int sig, void (*func)(int, char*, Ureg*)))(int, char*, Ureg*) +/* consider moving to */ +typedef void (*sighandler_t)(int); +typedef void (*isighandler_t)(int, char*, Ureg*); + void -(*signal(int sig, void (*func)()))() +(*signal(int sig, void (*func)(int)))(int) { - void(*oldf)(int, char*, Ureg*); + sighandler_t oldf; if(sig <= 0 || sig > MAXSIG){ errno = EINVAL; return SIG_ERR; } - oldf = _sighdlr[sig]; + oldf = (sighandler_t)_sighdlr[sig]; if(sig == SIGKILL) return oldf; /* can't catch or ignore SIGKILL */ - _sighdlr[sig] = func; + _sighdlr[sig] = (isighandler_t)func; return oldf; } @@ -90,12 +92,14 @@ /* this is registered in _envsetup */ int -_notehandler(void *u, char *msg) +_notehandler(void *v, char *msg) { int i; void(*f)(int, char*, Ureg*); + Ureg *u; extern void _doatexits(void); /* in stdio/exit.c */ + u = v; if(_finishing) _finish(0, 0); for(i = 0; iflags&FD_ISOPEN) && (db2=_dirfstat(i)) != nil) { if(db1->qid.path == db2->qid.path && @@ -67,10 +66,8 @@ free(db2); } } - n = 0; - if(fd == -1) - if((n=_REMOVE(path)) < 0) - _syserrno(); + if((n = _REMOVE(path)) < 0) + _syserrno(); free(db1); return n; } --- /sys/src/ape/lib/ap/plan9/write.c Fri Aug 23 08:17:43 2013 +++ /sys/src/ape/lib/ap/plan9/write.c Fri Aug 23 08:17:41 2013 @@ -1,21 +1,28 @@ #include +#include #include #include "lib.h" #include "sys9.h" ssize_t -write(int d, const void *buf, size_t nbytes) +pwrite(int fd, const void *buf, size_t nbytes, off_t off) { int n; - if(d<0 || d>=OPEN_MAX || !(_fdinfo[d].flags&FD_ISOPEN)){ + if(fd<0 || fd>=OPEN_MAX || !(_fdinfo[fd].flags&FD_ISOPEN)){ errno = EBADF; return -1; } - if(_fdinfo[d].oflags&O_APPEND) - _SEEK(d, 0, 2); - n = _WRITE(d, buf, nbytes); + if(_fdinfo[fd].oflags&O_APPEND) + _SEEK(fd, 0, 2); + n = _PWRITE(fd, buf, nbytes, off); if(n < 0) _syserrno(); return n; +} + +ssize_t +write(int fd, const void *buf, size_t nbytes) +{ + return pwrite(fd, buf, nbytes, -1ll); } --- /sys/src/ape/lib/ap/posix/getgrent.c Fri Aug 23 08:17:44 2013 +++ /sys/src/ape/lib/ap/posix/getgrent.c Fri Aug 23 08:17:43 2013 @@ -32,7 +32,7 @@ } static char * -grskip(register char *p, register c) +grskip(char *p, int c) { while( *p && *p != c ) ++p; if( *p ) *p++ = 0; @@ -40,9 +40,9 @@ } struct group * -getgrent() +getgrent(void) { - register char *p, **q; + char *p, **q; if( !grf && !(grf = fopen( GROUP, "r" )) ) return(NULL); --- /sys/src/ape/lib/ap/posix/getpwent.c Fri Aug 23 08:17:47 2013 +++ /sys/src/ape/lib/ap/posix/getpwent.c Fri Aug 23 08:17:46 2013 @@ -49,14 +49,16 @@ passwd.pw_dir = p; p = pwskip(p); passwd.pw_shell = p; - pwskip(p); + p = pwskip(p); + USED(p); + return(&passwd); } struct passwd * getpwent(void) { - register char *p; + char *p; if (pwf == NULL) { if( (pwf = fopen( PASSWD, "r" )) == NULL ) --- /sys/src/ape/lib/ap/posix/mkfifo.c Fri Aug 23 08:17:49 2013 +++ /sys/src/ape/lib/ap/posix/mkfifo.c Fri Aug 23 08:17:48 2013 @@ -3,8 +3,9 @@ #include int -mkfifo(char *, mode_t) +mkfifo(char *path, mode_t mode) { + USED(path, mode); errno = 0; return -1; } --- /sys/src/ape/lib/ap/posix/mkfile Fri Aug 23 08:17:53 2013 +++ /sys/src/ape/lib/ap/posix/mkfile Fri Aug 23 08:17:52 2013 @@ -13,4 +13,4 @@ long -pathconf(const char *, int name) +pathconf(const char *path, int name) { + USED(path); switch(name) { case _PC_LINK_MAX: @@ -44,8 +45,9 @@ } long -fpathconf(int, int name) +fpathconf(int fd, int name) { + USED(fd); return pathconf(0, name); } --- /sys/src/ape/lib/ap/power/mkfile Fri Aug 23 08:17:59 2013 +++ /sys/src/ape/lib/ap/power/mkfile Fri Aug 23 08:17:57 2013 @@ -19,5 +19,5 @@ state){ default: /* CLOSED, WR, ERR, EOF */ return EOF; case OPEN: - _IO_setvbuf(f); + if(_IO_setvbuf(f) != 0) + return EOF; case RDWR: case RD: if(f->flags&STRING) return EOF; @@ -17,6 +20,8 @@ else n = f->bufl; cnt=read(f->fd, f->buf, n); + if(f->state == CLOSED) + return EOF; switch(cnt){ case -1: f->state=ERR; return EOF; case 0: f->state=END; return EOF; --- /sys/src/ape/lib/ap/stdio/_IO_putc.c Fri Aug 23 08:18:06 2013 +++ /sys/src/ape/lib/ap/stdio/_IO_putc.c Fri Aug 23 08:18:05 2013 @@ -19,7 +19,8 @@ case CLOSED: return EOF; case OPEN: - _IO_setvbuf(f); + if(_IO_setvbuf(f)!=0) + return EOF; /* fall through */ case RDWR: case END: --- /sys/src/ape/lib/ap/stdio/_fconv.c Fri Aug 23 08:18:09 2013 +++ /sys/src/ape/lib/ap/stdio/_fconv.c Fri Aug 23 08:18:07 2013 @@ -103,9 +103,9 @@ } int -_hi0bits(register unsigned long x) +_hi0bits(unsigned long x) { - register int k = 0; + int k = 0; if (!(x & 0xffff0000)) { k = 16; @@ -134,8 +134,8 @@ static int lo0bits(unsigned long *y) { - register int k; - register unsigned long x = *y; + int k; + unsigned long x = *y; if (x & 7) { if (x & 1) --- /sys/src/ape/lib/ap/stdio/atexit.c Fri Aug 23 08:18:11 2013 +++ /sys/src/ape/lib/ap/stdio/atexit.c Fri Aug 23 08:18:10 2013 @@ -1,12 +1,13 @@ #include -#define NONEXIT 34 -extern void (*_atexitfns[NONEXIT])(void); +#include + +extern void (*_atexitfns[ATEXIT_MAX])(void); int atexit(void (*f)(void)) { int i; - for(i=0; i -#define NONEXIT 34 -void (*_atexitfns[NONEXIT])(void); -void _doatexits(void){ +#include + +void (*_atexitfns[ATEXIT_MAX])(void); + +void +_doatexits(void) +{ int i; void (*f)(void); - for(i = NONEXIT-1; i >= 0; i--) + + for(i = ATEXIT_MAX-1; i >= 0; i--) if(_atexitfns[i]){ f = _atexitfns[i]; - _atexitfns[i] = 0; /* self defense against bozos */ + _atexitfns[i] = NULL; /* self defense against bozos */ (*f)(); } } + void exit(int status) { _doatexits(); --- /sys/src/ape/lib/ap/stdio/fclose.c Fri Aug 23 08:18:14 2013 +++ /sys/src/ape/lib/ap/stdio/fclose.c Fri Aug 23 08:18:13 2013 @@ -3,12 +3,28 @@ */ #include "iolib.h" int fclose(FILE *f){ - int error=0; + int d, error=0; + char *p; + if(!f) return EOF; if(f->state==CLOSED) return EOF; if(fflush(f)==EOF) error=EOF; - if(f->flags&BALLOC) free(f->buf); - if(!(f->flags&STRING) && close(f->fd)<0) error=EOF; + if(f->flags&BALLOC){ + if((p = f->buf)!=0){ + f->buf = 0; + f->wp = 0; + f->rp = 0; + f->lp = 0; + free(p); + } + } + if(!(f->flags&STRING)){ + if((d = f->fd)>=0){ + f->fd = -1; + if(close(d) < 0) + error = EOF; + } + } f->state=CLOSED; f->flags=0; return error; --- /sys/src/ape/lib/ap/stdio/fdopen.c Fri Aug 23 08:18:16 2013 +++ /sys/src/ape/lib/ap/stdio/fdopen.c Fri Aug 23 08:18:15 2013 @@ -14,10 +14,8 @@ */ FILE *fdopen(const int fd, const char *mode){ FILE *f; - for(f=_IO_stream;f!=&_IO_stream[FOPEN_MAX];f++) - if(f->state==CLOSED) - break; - if(f==&_IO_stream[FOPEN_MAX]) + + if((f = _IO_newfile()) == NULL) return NULL; f->fd=fd; if(mode[0]=='a') --- /sys/src/ape/lib/ap/stdio/fflush.c Fri Aug 23 08:18:18 2013 +++ /sys/src/ape/lib/ap/stdio/fflush.c Fri Aug 23 08:18:17 2013 @@ -21,7 +21,8 @@ case WR: cnt=(f->flags&LINEBUF?f->lp:f->wp)-f->buf; if(cnt && write(f->fd, f->buf, cnt)!=cnt){ - f->state=ERR; + if(f->state != CLOSED) + f->state = ERR; return EOF; } f->rp=f->wp=f->buf; --- /sys/src/ape/lib/ap/stdio/fopen.c Fri Aug 23 08:18:20 2013 +++ /sys/src/ape/lib/ap/stdio/fopen.c Fri Aug 23 08:18:19 2013 @@ -2,10 +2,11 @@ * pANS stdio -- fopen */ #include "iolib.h" + FILE *fopen(const char *name, const char *mode){ FILE *f; - for(f=_IO_stream;f!=&_IO_stream[FOPEN_MAX];f++) - if(f->state==CLOSED) - return freopen(name, mode, f); - return NULL; + + if((f = _IO_newfile()) == NULL) + return NULL; + return freopen(name, mode, f); } --- /sys/src/ape/lib/ap/stdio/fread.c Fri Aug 23 08:18:22 2013 +++ /sys/src/ape/lib/ap/stdio/fread.c Fri Aug 23 08:18:21 2013 @@ -12,7 +12,7 @@ s=(char *)p; n=recl*nrec; - while(n>0){ + while(n>0 && f->state!=CLOSED){ d=f->wp-f->rp; if(d>0){ if(d>n) @@ -20,10 +20,11 @@ memcpy(s, f->rp, d); f->rp+=d; }else{ - if(n >= BIGN && f->state==RD && !(f->flags&STRING) && f->buf!=f->unbuf){ + if(f->buf==f->unbuf || (n >= BIGN && f->state==RD && !(f->flags&STRING))){ d=read(f->fd, s, n); if(d<=0){ - f->state=(d==0)?END:ERR; + if(f->state!=CLOSED) + f->state=(d==0)?END:ERR; goto ret; } }else{ --- /sys/src/ape/lib/ap/stdio/fwrite.c Fri Aug 23 08:18:24 2013 +++ /sys/src/ape/lib/ap/stdio/fwrite.c Fri Aug 23 08:18:23 2013 @@ -12,7 +12,7 @@ s=(char *)p; n=recl*nrec; - while(n>0){ + while(n>0 && f->state!=CLOSED){ d=f->rp-f->wp; if(d>0){ if(d>n) @@ -20,13 +20,14 @@ memcpy(f->wp, s, d); f->wp+=d; }else{ - if(n>=BIGN && f->state==WR && !(f->flags&(STRING|LINEBUF)) && f->buf!=f->unbuf){ + if(f->buf==f->unbuf || (n>=BIGN && f->state==WR && !(f->flags&(STRING|LINEBUF)))){ d=f->wp-f->buf; if(d>0){ if(f->flags&APPEND) lseek(f->fd, 0L, SEEK_END); if(write(f->fd, f->buf, d)!=d){ - f->state=ERR; + if(f->state!=CLOSED) + f->state=ERR; goto ret; } f->wp=f->rp=f->buf; @@ -35,7 +36,8 @@ lseek(f->fd, 0L, SEEK_END); d=write(f->fd, s, n); if(d<=0){ - f->state=ERR; + if(f->state!=CLOSED) + f->state=ERR; goto ret; } }else{ --- /sys/src/ape/lib/ap/stdio/iolib.h Fri Aug 23 08:18:26 2013 +++ /sys/src/ape/lib/ap/stdio/iolib.h Fri Aug 23 08:18:25 2013 @@ -42,3 +42,4 @@ FILE *_IO_sopenr(const char*); FILE *_IO_sopenw(void); char *_IO_sclose(FILE *); +FILE *_IO_newfile(void); --- /sys/src/ape/lib/ap/stdio/mkfile Fri Aug 23 08:18:30 2013 +++ /sys/src/ape/lib/ap/stdio/mkfile Fri Aug 23 08:18:29 2013 @@ -2,6 +2,7 @@ <$APE/config LIB=/$objtype/lib/ape/libap.a OFILES=\ + _IO_newfile.$O\ _IO_getc.$O\ _IO_putc.$O\ _dtoa.$O\ @@ -65,5 +66,5 @@ state=RD; case RD: @@ -46,6 +47,8 @@ break; } cnt=read(f->fd, f->wp, cnt); + if(f->state==CLOSED) + return NULL; if(cnt==-1){ f->state=ERR; return NULL; --- /sys/src/ape/lib/ap/stdio/snprintf.c Fri Aug 23 08:18:34 2013 +++ /sys/src/ape/lib/ap/stdio/snprintf.c Fri Aug 23 08:18:33 2013 @@ -1,6 +1,8 @@ /* * pANS stdio -- sprintf */ +#define _C99_SNPRINTF_EXTENSION + #include "iolib.h" int snprintf(char *buf, size_t nbuf, const char *fmt, ...){ --- /sys/src/ape/lib/ap/stdio/sopenr.c Fri Aug 23 08:18:36 2013 +++ /sys/src/ape/lib/ap/stdio/sopenr.c Fri Aug 23 08:18:35 2013 @@ -6,8 +6,9 @@ FILE *_IO_sopenr(const char *s){ FILE *f; - for(f=_IO_stream;f!=&_IO_stream[FOPEN_MAX];f++) if(f->state==CLOSED) break; - if(f==&_IO_stream[FOPEN_MAX]) return NULL; + + if((f=_IO_newfile())==NULL) + return NULL; f->buf=f->rp=(char *)s; /* what an annoyance const is */ f->bufl=strlen(s); f->wp=f->buf+f->bufl; --- /sys/src/ape/lib/ap/stdio/sopenw.c Fri Aug 23 08:18:38 2013 +++ /sys/src/ape/lib/ap/stdio/sopenw.c Fri Aug 23 08:18:37 2013 @@ -5,8 +5,9 @@ FILE *_IO_sopenw(void){ FILE *f; - for(f=_IO_stream;f!=&_IO_stream[FOPEN_MAX];f++) if(f->state==CLOSED) break; - if(f==&_IO_stream[FOPEN_MAX]) return NULL; + + if((f=_IO_newfile())==NULL) + return NULL; f->buf=f->rp=f->wp=0; f->state=OPEN; f->flags=STRING; --- /sys/src/ape/lib/ap/stdio/strtod.c Fri Aug 23 08:18:40 2013 +++ /sys/src/ape/lib/ap/stdio/strtod.c Fri Aug 23 08:18:39 2013 @@ -42,7 +42,7 @@ static double ulp(double xarg) { - register long L; + long L; Dul a; Dul x; --- /sys/src/ape/lib/ap/stdio/vfprintf.c Fri Aug 23 08:18:43 2013 +++ /sys/src/ape/lib/ap/stdio/vfprintf.c Fri Aug 23 08:18:41 2013 @@ -6,6 +6,9 @@ #include #include #include +#define _SUSV2_SOURCE +#include + /* * Leading flags */ @@ -202,13 +205,13 @@ nprint++; } } - return ferror(f)? -1: nprint;; + return ferror(f)? -1: nprint; } static int ocvt_c(FILE *f, va_list *args, int flags, int width, int precision) { -#pragma ref precision + USED(precision); int i; if(!(flags&LEFT)) for(i=1; i #include #include +#define _PLAN9_SOURCE +#include + static int icvt_f(FILE *f, va_list *args, int store, int width, int type); static int icvt_x(FILE *f, va_list *args, int store, int width, int type); static int icvt_sq(FILE *f, va_list *args, int store, int width, int type); @@ -59,12 +62,16 @@ #define wungetc(c, f) (++width, nungetc(c, f)) static int nread, ncvt; static const char *fmtp; +static QLock scanlock; /* lazy solution */ -int vfscanf(FILE *f, const char *s, va_list args){ +static int +vfscanf0(FILE *f, const char *s, va_list args) +{ int c, width, type, store; nread=0; ncvt=0; fmtp=s; + for(;*fmtp;fmtp++) switch(*fmtp){ default: if(isspace(*fmtp)){ @@ -105,9 +112,21 @@ } return ncvt; } + +int +vfscanf(FILE *f, const char *s, va_list args) +{ + int r; + + qlock(&scanlock); + r = vfscanf0(f, s, args); + qunlock(&scanlock); + + return r; +} + static int icvt_n(FILE *f, va_list *args, int store, int width, int type){ -#pragma ref f -#pragma ref width + USED(f, width); if(store){ --ncvt; /* this assignment doesn't count! */ switch(type){ @@ -279,10 +298,12 @@ return 1; } static int icvt_s(FILE *f, va_list *args, int store, int width, int type){ -#pragma ref type int c, nn; - register char *s; + char *s; + + USED(type); if(store) s=va_arg(*args, char *); + else s=NULL; do c=ngetc(f); while(isspace(c)); @@ -307,10 +328,12 @@ return 1; } static int icvt_c(FILE *f, va_list *args, int store, int width, int type){ -#pragma ref type int c; - register char *s; + char *s; + + USED(type); if(store) s=va_arg(*args, char *); + else s=NULL; if(width<0) width=1; for(;;){ wgetc(c, f, Done); @@ -339,15 +362,17 @@ return !ok; } static int icvt_sq(FILE *f, va_list *args, int store, int width, int type){ -#pragma ref type int c, nn; - register char *s; - register const char *pat; + char *s; + const char *pat; + + USED(type); pat=++fmtp; if(*fmtp=='^') fmtp++; if(*fmtp!='\0') fmtp++; while(*fmtp!='\0' && *fmtp!=']') fmtp++; if(store) s=va_arg(*args, char *); + else s=NULL; nn=0; for(;;){ wgetc(c, f, Done); --- /sys/src/ape/lib/ap/stdio/vsnprintf.c Fri Aug 23 08:18:47 2013 +++ /sys/src/ape/lib/ap/stdio/vsnprintf.c Fri Aug 23 08:18:46 2013 @@ -1,6 +1,8 @@ /* * pANS stdio -- vsnprintf */ +#define _C99_SNPRINTF_EXTENSION + #include "iolib.h" int vsnprintf(char *buf, size_t nbuf, const char *fmt, va_list args){ --- /sys/src/ape/lib/bsd/_sock_ingetaddr.c Fri Aug 23 08:18:49 2013 +++ /sys/src/ape/lib/bsd/_sock_ingetaddr.c Fri Aug 23 08:18:48 2013 @@ -16,32 +16,49 @@ #include "priv.h" void -_sock_ingetaddr(Rock *r, struct sockaddr_in *ip, int *alen, char *a) +_sock_ingetaddr(Rock *r, struct sockaddr *sa, int *alen, char *a) { int n, fd; char *p; char name[Ctlsize]; + struct sockaddr_in *ip; + struct sockaddr_in6 *ip6; /* get remote address */ strcpy(name, r->ctl); p = strrchr(name, '/'); strcpy(p+1, a); fd = open(name, O_RDONLY); - if(fd >= 0){ - n = read(fd, name, sizeof(name)-1); - if(n > 0){ - name[n] = 0; - p = strchr(name, '!'); - if(p){ - *p++ = 0; - ip->sin_family = AF_INET; - ip->sin_port = htons(atoi(p)); - ip->sin_addr.s_addr = inet_addr(name); - if(alen) - *alen = sizeof(struct sockaddr_in); - } - } + if(fd < 0) + return; + n = read(fd, name, sizeof(name)-1); + if(n < 0){ close(fd); + return; } + name[n] = 0; + if((p = strchr(name, '!')) != nil){ + *p++ = 0; + /* + * allow a AF_INET listen to accept a AF_INET6 call + * so a machine with ip4 and ip6 addresses can accept either. + */ + if(strchr(p, ':') != nil){ + ip = (struct sockaddr_in*)sa; + ip->sin_family = AF_INET; + ip->sin_port = htons(atoi(p)); + ip->sin_addr.s_addr = inet_addr(name); + if(alen) + *alen = sizeof(struct sockaddr_in); + }else{ + ip6 = (struct sockaddr_in6*)sa; + ip6->sin6_family = AF_INET6; + ip6->sin6_port = htons(atoi(p)); + inet_pton(AF_INET6, name, &ip6->sin6_addr); + if(alen) + *alen = sizeof(struct sockaddr_in6); + } + } + close(fd); } --- /sys/src/ape/lib/bsd/_sock_ipattr.c Fri Aug 23 08:18:51 2013 +++ /sys/src/ape/lib/bsd/_sock_ipattr.c Fri Aug 23 08:18:50 2013 @@ -1,7 +1,7 @@ /* posix */ #include #include -#include +#include /* bsd extensions */ #include @@ -16,30 +16,11 @@ int _sock_ipattr(char *name) { - char *p; - int dot = 0; - int alpha = 0; + struct in6_addr ia6; - for(p = name; *p; p++){ - if(isdigit(*p)){ - ; - }else if(isalpha(*p) || *p == '-') - alpha = 1; - else if(*p == '.') - dot = 1; - else - return Tsys; - } - - if(alpha){ - if(dot) - return Tdom; - else - return Tsys; - } - - if(dot) + if(inet_pton(AF_INET6, name, &ia6) == 1) return Tip; - else - return Tsys; + if(strchr(name, '.') != nil) + return Tdom; + return Tsys; } --- /sys/src/ape/lib/bsd/accept.c Fri Aug 23 08:18:53 2013 +++ /sys/src/ape/lib/bsd/accept.c Fri Aug 23 08:18:52 2013 @@ -6,6 +6,7 @@ #include #include #include +#include /* bsd extensions */ #include @@ -20,7 +21,6 @@ { int n, nfd, cfd; Rock *r, *nr; - struct sockaddr_in *ip; char name[Ctlsize]; char file[8+Ctlsize+1]; char *net; @@ -33,16 +33,17 @@ switch(r->domain){ case PF_INET: + case PF_INET6: switch(r->stype){ + default: + errno = EPROTONOSUPPORT; + return -1; case SOCK_DGRAM: net = "udp"; break; case SOCK_STREAM: net = "tcp"; break; - default: - net = "gok"; - break; } /* get control file name from listener process */ @@ -71,11 +72,10 @@ } /* get remote address */ - ip = (struct sockaddr_in*)&nr->raddr; - _sock_ingetaddr(nr, ip, &n, "remote"); - if(a){ - memmove(a, ip, sizeof(struct sockaddr_in)); - *alen = sizeof(struct sockaddr_in); + _sock_ingetaddr(nr, &nr->raddr, &n, "remote"); + if(a != nil){ + memmove(a, &nr->raddr, n); + *alen = n; } return nfd; --- /sys/src/ape/lib/bsd/bind.c Fri Aug 23 08:18:55 2013 +++ /sys/src/ape/lib/bsd/bind.c Fri Aug 23 08:18:54 2013 @@ -24,10 +24,9 @@ int bind(int fd, void *a, int alen) { - int n, len, cfd; + int n, len, cfd, port; Rock *r; char msg[128]; - struct sockaddr_in *lip; /* assign the address */ r = _sock_findrock(fd, 0); @@ -42,29 +41,30 @@ memmove(&r->addr, a, alen); /* the rest is IP sepecific */ - if (r->domain != PF_INET) - return 0; - - cfd = open(r->ctl, O_RDWR); - if(cfd < 0){ - errno = EBADF; - return -1; - } - lip = (struct sockaddr_in*)&r->addr; - if(lip->sin_port > 0) - snprintf(msg, sizeof msg, "bind %d", ntohs(lip->sin_port)); - else - strcpy(msg, "bind *"); - n = write(cfd, msg, strlen(msg)); - if(n < 0){ - errno = EOPNOTSUPP; /* Improve error reporting!!! */ + switch(r->domain){ + case PF_INET: + case PF_INET6: + cfd = open(r->ctl, O_RDWR); + if(cfd < 0){ + errno = EBADF; + return -1; + } + _sock_ntop(r->domain, &r->addr, nil, 0, &port); + if(port > 0) + snprintf(msg, sizeof msg, "bind %d", port); + else + strcpy(msg, "bind *"); + n = write(cfd, msg, strlen(msg)); + if(n < 0){ + errno = EOPNOTSUPP; /* Improve error reporting!!! */ + close(cfd); + return -1; + } close(cfd); - return -1; - } - close(cfd); - if(lip->sin_port <= 0) - _sock_ingetaddr(r, lip, &len, "local"); + if(port <= 0) + _sock_ingetaddr(r, &r->addr, &len, "local"); + } return 0; } --- /sys/src/ape/lib/bsd/connect.c Fri Aug 23 08:18:57 2013 +++ /sys/src/ape/lib/bsd/connect.c Fri Aug 23 08:18:56 2013 @@ -6,6 +6,7 @@ #include #include #include +#include /* bsd extensions */ #include @@ -19,14 +20,13 @@ connect(int fd, void *a, int alen) { Rock *r; - int n, cfd, nfd; - char msg[8+256+1], file[8+256+1]; - struct sockaddr_in *lip, *rip; + int n, cfd, nfd, lport, rport; + char msg[8+256+1], file[8+256+1], rip[48], *rflag; struct sockaddr_un *runix; static int vers; r = _sock_findrock(fd, 0); - if(r == 0){ + if(r == nil){ errno = ENOTSOCK; return -1; } @@ -38,23 +38,23 @@ switch(r->domain){ case PF_INET: + case PF_INET6: /* set up a tcp or udp connection */ cfd = open(r->ctl, O_RDWR); if(cfd < 0){ _syserrno(); return -1; } - rip = a; - lip = (struct sockaddr_in*)&r->addr; - if(lip->sin_port) + + _sock_ntop(r->domain, &r->raddr, rip, sizeof rip, &rport); + _sock_ntop(r->domain, &r->addr, nil, 0, &lport); + rflag = r->reserved? "!r": ""; + if(lport) snprintf(msg, sizeof msg, "connect %s!%d%s %d", - inet_ntoa(rip->sin_addr), ntohs(rip->sin_port), - r->reserved ? "!r" : "", - ntohs(lip->sin_port)); + rip, rport, rflag, lport); else snprintf(msg, sizeof msg, "connect %s!%d%s", - inet_ntoa(rip->sin_addr), ntohs(rip->sin_port), - r->reserved ? "!r" : ""); + rip, rport, rflag); n = write(cfd, msg, strlen(msg)); if(n < 0){ _syserrno(); --- /sys/src/ape/lib/bsd/gethostbyaddr.c Fri Aug 23 08:18:59 2013 +++ /sys/src/ape/lib/bsd/gethostbyaddr.c Fri Aug 23 08:18:58 2013 @@ -11,19 +11,10 @@ int h_errno; struct hostent* -gethostbyaddr(void *addr, int len, int type) +gethostbyaddr(void *addr, int len, int af) { - unsigned long y; - struct in_addr x; - unsigned char *p = addr; + char name[64]; - if(type != AF_INET || len != 4){ - h_errno = NO_RECOVERY; - return 0; - } - - y = (p[0]<<24)|(p[1]<<16)|(p[2]<<8)|p[3]; - x.s_addr = htonl(y); - - return gethostbyname(inet_ntoa(x)); + USED(len); + return gethostbyname(inet_ntop(af, addr, name, sizeof name)); } --- /sys/src/ape/lib/bsd/gethostbyname.c Fri Aug 23 08:19:01 2013 +++ /sys/src/ape/lib/bsd/gethostbyname.c Fri Aug 23 08:19:00 2013 @@ -30,13 +30,13 @@ { int i, t, fd, m; char *p, *bp; - int nn, na; - unsigned long x; + int nn, na, na6; static struct hostent h; static char buf[1024]; static char *nptr[Nname+1]; static char *aptr[Nname+1]; - static char addr[Nname][4]; + static char addr4[Nname][4]; + static char addr6[Nname][16]; h.h_name = 0; t = _sock_ipattr(name); @@ -79,7 +79,7 @@ buf[i] = 0; /* parse the reply */ - nn = na = 0; + nn = na = na6 = 0; for(bp = buf;;){ p = strchr(bp, '='); if(p == 0) @@ -94,15 +94,12 @@ if(nn < Nname) nptr[nn++] = p; } else if(strcmp(bp, "ip") == 0){ - x = inet_addr(p); - x = ntohl(x); - if(na < Nname){ - addr[na][0] = x>>24; - addr[na][1] = x>>16; - addr[na][2] = x>>8; - addr[na][3] = x; - aptr[na] = addr[na]; - na++; + if(strchr(p, ':') != nil){ + if(inet_pton(AF_INET6, p, addr6[na6]) == 1) + na6++; + }else{ + if(inet_pton(AF_INET, p, addr4[na]) == 1) + na++; } } while(*p && *p != ' ') @@ -111,17 +108,29 @@ *p++ = 0; bp = p; } - if(nn+na == 0){ + if(nn+na+na6 == 0){ h_errno = HOST_NOT_FOUND; return 0; } nptr[nn] = 0; - aptr[na] = 0; + + if(na == 0){ + for(i = 0; i < na6; i++) + aptr[i] = addr6[i]; + aptr[i] = 0; + h.h_addrtype = AF_INET6; + h.h_length = 16; + }else{ + for(i = 0; i < na; i++) + aptr[i] = addr4[i]; + aptr[i] = 0; + h.h_addrtype = AF_INET; + h.h_length = 4; + } + h.h_aliases = nptr; h.h_addr_list = aptr; - h.h_length = 4; - h.h_addrtype = AF_INET; if(h.h_name == 0) h.h_name = nptr[0]; if(h.h_name == 0) --- /sys/src/ape/lib/bsd/gethostname.c Fri Aug 23 08:19:03 2013 +++ /sys/src/ape/lib/bsd/gethostname.c Fri Aug 23 08:19:02 2013 @@ -6,7 +6,7 @@ #include int -gethostname(char *name, int namelen) +gethostname(char *name, size_t namelen) { int n, fd; char buf[128]; --- /sys/src/ape/lib/bsd/getopt.c Fri Aug 23 08:19:05 2013 +++ /sys/src/ape/lib/bsd/getopt.c Fri Aug 23 08:19:04 2013 @@ -11,8 +11,8 @@ getopt (int argc, char **argv, char *opts) { static int sp = 1; - register c; - register char *cp; + int c; + char *cp; if (sp == 1) if (optind >= argc || --- /sys/src/ape/lib/bsd/getpeername.c Fri Aug 23 08:19:06 2013 +++ /sys/src/ape/lib/bsd/getpeername.c Fri Aug 23 08:19:05 2013 @@ -6,6 +6,7 @@ #include #include #include +#include /* bsd extensions */ #include @@ -15,25 +16,35 @@ #include "priv.h" +static int +connected(Rock *r, int len) +{ + static struct sockaddr niladdr; + + return memcmp(&r->raddr, &niladdr, len) != 0; +} + int getpeername(int fd, void *addr, int *alen) { Rock *r; int i; - struct sockaddr_in *rip; struct sockaddr_un *runix; r = _sock_findrock(fd, 0); - if(r == 0){ + if(r == nil){ errno = ENOTSOCK; return -1; } switch(r->domain){ case PF_INET: - rip = (struct sockaddr_in*)&r->raddr; - memmove(addr, rip, sizeof(struct sockaddr_in)); *alen = sizeof(struct sockaddr_in); + memmove(addr, &r->raddr, *alen); + break; + case PF_INET6: + *alen = sizeof(struct sockaddr_in6); + memmove(addr, &r->raddr, *alen); break; case PF_UNIX: runix = (struct sockaddr_un*)&r->raddr; @@ -43,6 +54,12 @@ break; default: errno = EAFNOSUPPORT; + return -1; + } + + if(!connected(r, *alen)){ + errno = ENOTCONN; + memset(&addr, 0, *alen); /* python depends on this */ return -1; } return 0; --- /sys/src/ape/lib/bsd/getprotobyname.c Fri Aug 23 08:19:08 2013 +++ /sys/src/ape/lib/bsd/getprotobyname.c Fri Aug 23 08:19:07 2013 @@ -24,7 +24,8 @@ static struct protoent r; -struct protoent *getprotobyname(const char *name) { +struct protoent* +getprotobyname(const char *name) { int fd, i, m; char *p, *bp; int nn, na; --- /sys/src/ape/lib/bsd/getservbyaddr.c Fri Aug 23 08:19:10 2013 +++ /sys/src/ape/lib/bsd/getservbyaddr.c Fri Aug 23 08:19:09 2013 @@ -13,6 +13,6 @@ { char buf[32]; - snprintf(buf, sizeof buf, "%d", port); + snprintf(buf, sizeof buf, "%d", ntohs(port)); return getservbyname(buf, proto); } --- /sys/src/ape/lib/bsd/getservbyname.c Fri Aug 23 08:19:12 2013 +++ /sys/src/ape/lib/bsd/getservbyname.c Fri Aug 23 08:19:11 2013 @@ -49,8 +49,10 @@ } /* construct the query, always expect an ip# back */ - if(num) + if(num && proto != nil) snprintf(buf, sizeof buf, "!port=%s %s=*", name, proto); + else if(num) + snprintf(buf, sizeof buf, "!port=%s", name); else snprintf(buf, sizeof buf, "!%s=%s port=*", proto, name); @@ -76,10 +78,13 @@ if(p == 0) break; *p++ = 0; - if(strcmp(bp, proto) == 0){ + if(proto != nil && strcmp(bp, proto) == 0){ if(nn < Nname) nptr[nn++] = p; - } else if(strcmp(bp, "port") == 0){ + } else if(strcmp(bp, "port") != 0){ + if(nn < Nname) + nptr[nn++] = p; + } else{ s.s_port = htons(atoi(p)); } while(*p && *p != ' ') --- /sys/src/ape/lib/bsd/getsockname.c Fri Aug 23 08:19:14 2013 +++ /sys/src/ape/lib/bsd/getsockname.c Fri Aug 23 08:19:13 2013 @@ -6,6 +6,7 @@ #include #include #include +#include /* bsd extensions */ #include @@ -20,7 +21,6 @@ { Rock *r; int i; - struct sockaddr_in *lip; struct sockaddr_un *lunix; r = _sock_findrock(fd, 0); @@ -31,8 +31,8 @@ switch(r->domain){ case PF_INET: - lip = (struct sockaddr_in*)addr; - _sock_ingetaddr(r, lip, alen, "local"); + case PF_INET6: + _sock_ingetaddr(r, addr, alen, "local"); break; case PF_UNIX: lunix = (struct sockaddr_un*)&r->addr; --- /sys/src/ape/lib/bsd/listen.c Fri Aug 23 08:19:16 2013 +++ /sys/src/ape/lib/bsd/listen.c Fri Aug 23 08:19:15 2013 @@ -8,6 +8,9 @@ #include #include #include +#include +#define _SUSV2_SOURCE +#include /* socket extensions */ #include @@ -39,17 +42,18 @@ char *p; char listen[Ctlsize]; char name[Ctlsize]; + void *v; switch(r->stype){ + default: + errno = EOPNOTSUPP; + return -1; case SOCK_DGRAM: net = "udp"; break; case SOCK_STREAM: net = "tcp"; break; - default: - net = "gok"; - break; } strcpy(listen, r->ctl); @@ -81,11 +85,14 @@ _muxsid = getpgrp(); } else setpgid(getpid(), _muxsid); - _RENDEZVOUS(2, _muxsid); + while(_RENDEZVOUS((void*)2, (void*)_muxsid) == (void*)~0) + ; break; default: atexit(_killmuxsid); - _muxsid = _RENDEZVOUS(2, 0); + while((v = _RENDEZVOUS((void*)2, 0)) == (void*)~0) + ; + _muxsid = (int)(uintptr_t)v; close(pfd[1]); close(nfd); return 0; @@ -116,12 +123,11 @@ } int -listen(int fd, int) +listen(int fd, int /*backlog*/) { Rock *r; - int n, cfd; + int n, cfd, port; char msg[128]; - struct sockaddr_in *lip; struct sockaddr_un *lunix; r = _sock_findrock(fd, 0); @@ -132,20 +138,20 @@ switch(r->domain){ case PF_INET: + case PF_INET6: cfd = open(r->ctl, O_RDWR); if(cfd < 0){ errno = EBADF; return -1; } - lip = (struct sockaddr_in*)&r->addr; - if(1 || lip->sin_port >= 0) { /* sin_port is unsigned */ + _sock_ntop(r->domain, &r->addr, nil, 0, &port); + if(port != 0 && port != 0xffff) { if(write(cfd, "bind 0", 6) < 0) { errno = EGREG; close(cfd); return -1; } - snprintf(msg, sizeof msg, "announce %d", - ntohs(lip->sin_port)); + snprintf(msg, sizeof msg, "announce %d", port); } else strcpy(msg, "announce *"); --- /sys/src/ape/lib/bsd/lstat.c Fri Aug 23 08:19:18 2013 +++ /sys/src/ape/lib/bsd/lstat.c Fri Aug 23 08:19:17 2013 @@ -9,14 +9,14 @@ } int -symlink(char *, char *) +symlink(char*, char*) { errno = EPERM; return -1; } int -readlink(char *, char *, int ) +readlink(char*, char*, int) { errno = EIO; return -1; --- /sys/src/ape/lib/bsd/mkfile Fri Aug 23 08:19:22 2013 +++ /sys/src/ape/lib/bsd/mkfile Fri Aug 23 08:19:21 2013 @@ -9,10 +9,13 @@ connect.$O\ endhostent.$O\ ffs.$O\ + gai_strerr.$O\ + getaddrinfo.$O\ getdtablesize.$O\ - gethostbyname.$O\ gethostbyaddr.$O\ + gethostbyname.$O\ gethostname.$O\ + getnameinfo.$O\ getopt.$O\ getpeername.$O\ getprotobyname.$O\ @@ -20,9 +23,13 @@ getservbyname.$O\ getsockname.$O\ gettimeofday.$O\ + herror.$O\ inet_addr.$O\ inet_ntoa.$O\ + inet_ntop.$O\ + inet_pton.$O\ ioctl.$O\ + ip6const.$O\ listen.$O\ lstat.$O\ mktemp.$O\ @@ -39,6 +46,7 @@ shutdown.$O\ _sock_ingetaddr.$O\ _sock_ipattr.$O\ + _sock_ntop.$O\ _sock_srv.$O\ strcasecmp.$O\ strncasecmp.$O\ @@ -51,4 +59,4 @@ #include #include #include #include +extern char **environ; + +static int +envredo(char *s) +{ + char *x, **p, *q, **v, *mem; + int n, nsz, nenv, esz; + + x = strchr(s, '='); + if(x == NULL) + return -1; + nsz = x - s + 1; /* compare the var=, not just var */ + + nenv = 1; + esz = strlen(s)+1; + for(p = environ; (q = *p) != NULL; p++){ + esz += strlen(q)+1; + nenv++; + } + + /* overestimate in the case we have changed a variable. */ + v = malloc((nenv+1)*sizeof(char**) + esz); + if(v == NULL) + return -1; + mem = (char*)(v + nenv + 1); + + nenv = 0; + for(p = environ; (q = *p) != NULL; p++){ + if(strncmp(q, s, nsz) == 0) + continue; + v[nenv++] = mem; + n = strlen(q)+1; + memcpy(mem, q, n); + mem += n; + } + v[nenv++] = mem; + n = strlen(s)+1; + memcpy(mem, s, n); + + v[nenv] = NULL; + + free(environ); + environ = v; + + return 0; +} + int putenv(char *s) { @@ -26,7 +74,7 @@ if(write(f, value, n) != n) return -1; close(f); - return 0; + return envredo(s); } else return -1; } --- /sys/src/ape/lib/bsd/rcmd.c Fri Aug 23 08:19:30 2013 +++ /sys/src/ape/lib/bsd/rcmd.c Fri Aug 23 08:19:28 2013 @@ -6,6 +6,7 @@ #include #include #include +#include /* socket extensions */ #include @@ -23,6 +24,7 @@ { } +/* no ip6 and i don't care */ int rcmd(char **dst, int port, char *luser, char *ruser, char *cmd, int *fd2p) { @@ -92,6 +94,8 @@ if(write(fd, luser, strlen(luser)+1) < 0 || write(fd, ruser, strlen(ruser)+1) < 0 || write(fd, cmd, strlen(cmd)+1) < 0){ + if(fd2p) + close(lfd); fprintf(stderr, pbotch); return -1; } @@ -116,10 +120,8 @@ /* get reply */ if(read(fd, &c, 1) != 1){ - if(fd2p){ + if(fd2p) close(fd2); - *fd2p = -1; - } fprintf(stderr, pbotch); return -1; } --- /sys/src/ape/lib/bsd/sendto.c Fri Aug 23 08:19:31 2013 +++ /sys/src/ape/lib/bsd/sendto.c Fri Aug 23 08:19:30 2013 @@ -11,8 +11,10 @@ #include "priv.h" int -sendto(int fd, void *a, int n, int flags, void *, int) +sendto(int fd, void *a, int n, int flags, + void *to, int tolen) { + USED(to, tolen); /* actually, should do connect if not done already */ return send(fd, a, n, flags); } --- /sys/src/ape/lib/bsd/socket.c Fri Aug 23 08:19:33 2013 +++ /sys/src/ape/lib/bsd/socket.c Fri Aug 23 08:19:32 2013 @@ -42,11 +42,8 @@ r = _sock_findrock(fd, &d); if(r == 0){ r = malloc(sizeof(Rock)); - if(r == 0) - return 0; - r->dev = d.st_dev; - r->inode = d.st_ino; - r->other = -1; + if(r == nil) + return nil; r->next = _sock_rock; _sock_rock = r; } @@ -115,6 +112,7 @@ switch(domain){ case PF_INET: + case PF_INET6: /* get a free network directory */ switch(stype){ case SOCK_DGRAM: --- /sys/src/ape/lib/bsd/socketpair.c Fri Aug 23 08:19:35 2013 +++ /sys/src/ape/lib/bsd/socketpair.c Fri Aug 23 08:19:34 2013 @@ -9,8 +9,9 @@ #include int -socketpair(int domain, int , int , int *sv) +socketpair(int domain, int type, int protocol, int *sv) { + USED(protocol, type); switch(domain){ case PF_UNIX: return pipe(sv); --- /sys/src/ape/lib/draw/mkfile Fri Aug 23 08:19:40 2013 +++ /sys/src/ape/lib/draw/mkfile Fri Aug 23 08:19:39 2013 @@ -69,7 +69,7 @@ #include +#define _SUSV2_SOURCE +#include #include "utf.h" #include "fmt.h" #include "fmtdef.h" @@ -329,6 +331,7 @@ char buf[70], *p, *conv; uvlong vu; ulong u; + uintptr_t pu; int neg, base, i, n, fl, w, isv; neg = 0; @@ -348,7 +351,12 @@ break; } if(f->r == 'p'){ - u = (ulong)va_arg(f->args, void*); + pu = va_arg(f->args, uintptr_t); + if(sizeof(uintptr_t) == sizeof(uvlong)){ + vu = pu; + isv = 1; + }else + u = pu; f->r = 'x'; fl |= FmtUnsigned; }else if(fl & FmtVLong){ --- /sys/src/ape/lib/fmt/fmt.c Fri Aug 23 08:19:44 2013 +++ /sys/src/ape/lib/fmt/fmt.c Fri Aug 23 08:19:43 2013 @@ -80,7 +80,7 @@ { Convfmt *p, *ep; - if(c<=0 || c>=65536) + if(c<=0 || c>Runemax) return -1; if(!f) f = __badfmt; --- /sys/src/ape/lib/fmt/fmtdef.h Fri Aug 23 08:19:46 2013 +++ /sys/src/ape/lib/fmt/fmtdef.h Fri Aug 23 08:19:45 2013 @@ -25,8 +25,6 @@ #define vlong _fmtvlong #define uvlong _fmtuvlong -// #define USED(x) if(x);else - typedef unsigned char uchar; typedef unsigned short ushort; typedef unsigned int uint; --- /sys/src/ape/lib/fmt/fmtfdflush.c Fri Aug 23 08:19:48 2013 +++ /sys/src/ape/lib/fmt/fmtfdflush.c Fri Aug 23 08:19:47 2013 @@ -13,6 +13,8 @@ */ #include #include +#define _SUSV2_SOURCE +#include #include "fmt.h" #include "fmtdef.h" @@ -26,7 +28,7 @@ int n; n = (char*)f->to - (char*)f->start; - if(n && write((int)f->farg, f->start, n) != n) + if(n && write((int)(uintptr_t)f->farg, f->start, n) != n) return 0; f->to = f->start; return 1; --- /sys/src/ape/lib/fmt/fmtstr.c Fri Aug 23 08:19:50 2013 +++ /sys/src/ape/lib/fmt/fmtstr.c Fri Aug 23 08:19:49 2013 @@ -14,6 +14,8 @@ #include #include #include +#define _SUSV2_SOURCE +#include #include "utf.h" #include "fmt.h" #include "fmtdef.h" @@ -24,7 +26,7 @@ char *s; int n; - n = (int)f->farg; + n = (int)(uintptr_t)f->farg; n += 256; f->farg = (void*)n; s = (char*)f->start; --- /sys/src/ape/lib/fmt/mkfile Fri Aug 23 08:19:54 2013 +++ /sys/src/ape/lib/fmt/mkfile Fri Aug 23 08:19:53 2013 @@ -56,4 +56,4 @@ $CC -o test test.$O $LIB -L$PLAN9/lib -lutf -CFLAGS=$CFLAGS -c -D_POSIX_SOURCE -D_PLAN9_SOURCE -D_BSD_EXTENSION +CFLAGS=-FVTwc -D_POSIX_SOURCE -D_PLAN9_SOURCE -D_BSD_EXTENSION --- /sys/src/ape/lib/fmt/runefmtstr.c Fri Aug 23 08:19:56 2013 +++ /sys/src/ape/lib/fmt/runefmtstr.c Fri Aug 23 08:19:55 2013 @@ -14,6 +14,8 @@ #include #include #include +#define _SUSV2_SOURCE +#include #include "utf.h" #include "fmt.h" #include "fmtdef.h" @@ -24,7 +26,7 @@ Rune *s; int n; - n = (int)f->farg; + n = (int)(uintptr_t)f->farg; n += 256; f->farg = (void*)n; s = (Rune*)f->start; --- /sys/src/ape/lib/l/mkfile Fri Aug 23 08:20:00 2013 +++ /sys/src/ape/lib/l/mkfile Fri Aug 23 08:19:59 2013 @@ -10,4 +10,4 @@ /tm0->tm_/g' | \ + sed 's/static //g' > x509-ape.c $O.rsatest: rsatest.$O $LD -o $target $prereq --- /sys/src/ape/lib/sec/port/reduce Fri Aug 23 08:21:19 2013 +++ /sys/src/ape/lib/sec/port/reduce Fri Aug 23 08:21:18 2013 @@ -1,3 +1,4 @@ +#!/bin/rc O=$1 shift objtype=$1 --- /sys/src/ape/lib/sec/power/mkfile Fri Aug 23 08:21:25 2013 +++ /sys/src/ape/lib/sec/power/mkfile Fri Aug 23 08:21:24 2013 @@ -10,3 +10,6 @@ UPDATE=mkfile T2 Tx + * 0080-07FF => T2 Tx */ c1 = *(uchar*)(str+1) ^ Tx; if(c1 & Testx) @@ -81,18 +78,15 @@ /* * three character sequence - * 00800-0FFFF => T3 Tx Tx + * 0800-FFFF => T3 Tx Tx */ c2 = *(uchar*)(str+2) ^ Tx; - if(c2 & Testx) goto bad; if(c < T4) { l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3; if(l <= Rune2) goto bad; - if (SurrogateMin <= l && l <= SurrogateMax) - goto bad; *rune = l; return 3; } @@ -141,29 +135,21 @@ /* * two character sequence - * 0080-07FF => T2 Tx + * 00080-007FF => T2 Tx */ if(c <= Rune2) { str[0] = T2 | (c >> 1*Bitx); str[1] = Tx | (c & Maskx); return 2; } - /* - * If the Rune is out of range or a surrogate half, convert it to the error rune. - * Do this test here because the error rune encodes to three bytes. - * Doing it earlier would duplicate work, since an out of range - * Rune wouldn't have fit in one or two bytes. - */ - if (c > Runemax) - c = Runeerror; - if (SurrogateMin <= c && c <= SurrogateMax) - c = Runeerror; /* * three character sequence - * 0800-FFFF => T3 Tx Tx + * 00800-0FFFF => T3 Tx Tx */ - if (c <= Rune3) { + if(c > Runemax) + c = Runeerror; + if(c <= Rune3) { str[0] = T3 | (c >> 2*Bitx); str[1] = Tx | ((c >> 1*Bitx) & Maskx); str[2] = Tx | (c & Maskx); @@ -171,13 +157,13 @@ } /* - * four character sequence (21-bit value) - * 10000-1FFFFF => T4 Tx Tx Tx + * four character sequence + * 010000-1FFFFF => T4 Tx Tx Tx */ - str[0] = T4 | (c >> 3*Bitx); + str[0] = T4 | (c >> 3*Bitx); str[1] = Tx | ((c >> 2*Bitx) & Maskx); str[2] = Tx | ((c >> 1*Bitx) & Maskx); - str[3] = Tx | (c & Maskx); + str[3] = Tx | (c & Maskx); return 4; } @@ -201,10 +187,12 @@ c = *r++; if(c <= Rune1) nb++; - else if(c <= Rune2) + else + if(c <= Rune2) nb += 2; - else if(c <= Rune3) - nb += 3; + else + if(c <= Rune3 || c > Runemax) + nb += 3; else nb += 4; } @@ -215,6 +203,7 @@ fullrune(char *str, int n) { int c; + if(n <= 0) return 0; c = *(uchar*)str; @@ -222,7 +211,7 @@ return 1; if(c < T3) return n >= 2; - if(c < T4) + if(UTFmax == 3 || c < T4) return n >= 3; return n >= 4; } --- /sys/src/ape/lib/v/getfields.c Fri Aug 23 08:21:36 2013 +++ /sys/src/ape/lib/v/getfields.c Fri Aug 23 08:21:35 2013 @@ -27,8 +27,8 @@ char * setfields(char *arg) { - register unsigned char *s; - register i; + unsigned char *s; + int i; for(i = 1, s = (unsigned char *)last_sep; i < 256; i++) if(is_sep[i]) @@ -47,9 +47,9 @@ int getfields(char *ss, char **sp, int nptrs) { - register unsigned char *s = (unsigned char *)ss; - register unsigned char **p = (unsigned char **)sp; - register unsigned c; + unsigned char *s = (unsigned char *)ss; + unsigned char **p = (unsigned char **)sp; + unsigned c; c = 0; for(;;){ @@ -70,9 +70,9 @@ int getmfields(char *ss, char **sp, int nptrs) { - register unsigned char *s = (unsigned char *)ss; - register unsigned char **p = (unsigned char **)sp; - register unsigned c; + unsigned char *s = (unsigned char *)ss; + unsigned char **p = (unsigned char **)sp; + unsigned c; if(nptrs <= 0) return(0); --- /sys/src/ape/lib/v/mkfile Fri Aug 23 08:21:43 2013 +++ /sys/src/ape/lib/v/mkfile Fri Aug 23 08:21:42 2013 @@ -15,7 +15,7 @@ 0){ - for(i = 0; i < 1000*1000*10; i++) - ; - } + _SLEEP((n*16667)/1000); return 0; } --- /sys/src/ape/lib/v/plan9/tty.c Fri Aug 23 08:21:47 2013 +++ /sys/src/ape/lib/v/plan9/tty.c Fri Aug 23 08:21:46 2013 @@ -14,8 +14,9 @@ /* fd is ignored */ -tty_echooff(int) +tty_echooff(int fd) { + USED(fd); if(ctlfd >= 0) return 0; ctlfd = open("/dev/consctl", O_WRONLY); @@ -25,8 +26,9 @@ return 0; } -tty_echoon(int) +tty_echoon(int fd) { + USED(fd); if(ctlfd >= 0){ write(ctlfd, "rawoff", 6); close(ctlfd);