diff options
Diffstat (limited to 'mdk-stage1/dietlibc/libugly')
52 files changed, 1448 insertions, 523 deletions
diff --git a/mdk-stage1/dietlibc/libugly/asctime_r.c b/mdk-stage1/dietlibc/libugly/asctime_r.c index 46325927c..43c5e2cb2 100644 --- a/mdk-stage1/dietlibc/libugly/asctime_r.c +++ b/mdk-stage1/dietlibc/libugly/asctime_r.c @@ -16,7 +16,7 @@ char *asctime_r(const struct tm *t, char *buf) { if (buf[8]=='0') buf[8]=' '; buf[10]=' '; num2str(buf+11,t->tm_hour); - if (buf[11]=='0') buf[11]=' '; +// if (buf[11]=='0') buf[11]=' '; buf[13]=':'; num2str(buf+14,t->tm_min); buf[16]=':'; diff --git a/mdk-stage1/dietlibc/libugly/asprintf.c b/mdk-stage1/dietlibc/libugly/asprintf.c index d10c20b4a..9db1f67c7 100644 --- a/mdk-stage1/dietlibc/libugly/asprintf.c +++ b/mdk-stage1/dietlibc/libugly/asprintf.c @@ -1,21 +1,18 @@ #include <stdarg.h> -#include <linux/types.h> +#include <sys/types.h> #include <stdlib.h> +#include <stdio.h> #include "dietwarning.h" -extern int vsnprintf (char *str,size_t size,const char *format, va_list arg_ptr); - int asprintf(char **s, const char *format,...) { int n; va_list arg_ptr; va_start(arg_ptr, format); n=vsnprintf(0,1000000,format,arg_ptr); - va_end (arg_ptr); va_start (arg_ptr, format); - if ((*s=malloc(n+2))) { + if ((*s=malloc(n+1))) { n=vsnprintf(*s,n+1,format,arg_ptr); - va_end(arg_ptr); return n; } return -1; diff --git a/mdk-stage1/dietlibc/libugly/daemon.c b/mdk-stage1/dietlibc/libugly/daemon.c deleted file mode 100644 index 6748cc3c9..000000000 --- a/mdk-stage1/dietlibc/libugly/daemon.c +++ /dev/null @@ -1,35 +0,0 @@ -#include <sys/types.h> -#include <sys/stat.h> -#include <fcntl.h> -#include <unistd.h> -#include <paths.h> - -#include "daemon.h" - -int daemon (int nochdir,int noclose) -{ - int fd; - switch (fork ()) - { - case -1: - return (-1); - case 0: - break; - default: - _exit (0); - } - if (setsid () == -1) - return (-1); - if (!nochdir) chdir ("/"); - if (!noclose) - { - fd = open (_PATH_DEVNULL,O_RDWR,0); - if (fd == -1) return (-1); - dup2 (fd,STDIN_FILENO); - dup2 (fd,STDOUT_FILENO); - dup2 (fd,STDERR_FILENO); - close (fd); - } - return (0); -} - diff --git a/mdk-stage1/dietlibc/libugly/difftime.c b/mdk-stage1/dietlibc/libugly/difftime.c new file mode 100644 index 000000000..fc71363c7 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/difftime.c @@ -0,0 +1,8 @@ +#include <time.h> +#include "../dietwarning.h" + +double difftime(time_t time1, time_t time2) { + return (double)time1 - (double)time2; +} + +link_warning("difftime","warning: difftime introduces an unnecessary floating point dependency. Don't use it!") diff --git a/mdk-stage1/dietlibc/libugly/dirfd.c b/mdk-stage1/dietlibc/libugly/dirfd.c new file mode 100644 index 000000000..8d5af8b9a --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/dirfd.c @@ -0,0 +1,8 @@ +#include <sys/types.h> +#include "dietdirent.h" +#define _BSD_SOURCE +#include <dirent.h> + +int dirfd(DIR* dirp) { + return dirp->fd; +} diff --git a/mdk-stage1/dietlibc/libugly/freeaddrinfo.c b/mdk-stage1/dietlibc/libugly/freeaddrinfo.c new file mode 100644 index 000000000..72a13f5e1 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/freeaddrinfo.c @@ -0,0 +1,11 @@ +#include <sys/socket.h> +#include <stdlib.h> + +void freeaddrinfo(struct addrinfo *res) { + while (res) { + struct addrinfo *duh; + duh=res; + res=res->ai_next; + free(duh); + } +} diff --git a/mdk-stage1/dietlibc/libugly/ftime.c b/mdk-stage1/dietlibc/libugly/ftime.c new file mode 100644 index 000000000..3aa2d15c3 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/ftime.c @@ -0,0 +1,15 @@ +#include <sys/time.h> +#include <sys/timeb.h> +#include <unistd.h> + +int ftime(struct timeb *tp) { + struct timeval tv; + struct timezone tz; + int ret=gettimeofday(&tv,&tz); + tp->time = tv.tv_sec; + tp->millitm = tv.tv_usec/1000; + tp->timezone = tz.tz_minuteswest; + tp->dstflag = tz.tz_dsttime; + return ret; +} + diff --git a/mdk-stage1/dietlibc/libugly/gai_strerror.c b/mdk-stage1/dietlibc/libugly/gai_strerror.c new file mode 100644 index 000000000..9dc4f5dde --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/gai_strerror.c @@ -0,0 +1,13 @@ +#include <sys/socket.h> + +const char* gai_strerror(int error) { + switch (error) { + case EAI_FAMILY: return "family not supported"; + case EAI_SOCKTYPE: return "socket type not supported"; + case EAI_NONAME: return "unknown host"; + case EAI_SERVICE: return "unknown service"; + case EAI_MEMORY: return "memory allocation failure"; + case EAI_AGAIN: return "temporary failure"; + } + return "DNS error. Sorry."; +} diff --git a/mdk-stage1/dietlibc/libugly/getaddrinfo.c b/mdk-stage1/dietlibc/libugly/getaddrinfo.c new file mode 100644 index 000000000..a4675d92b --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getaddrinfo.c @@ -0,0 +1,140 @@ +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <stdlib.h> +#include <string.h> +#include <netdb.h> +#include <arpa/inet.h> + +/* XXX TODO FIXME */ + +int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) { + struct addrinfo **tmp; + int family; + tmp=res; *res=0; + if (hints) { + if (hints->ai_family && hints->ai_family != PF_INET6 && hints->ai_family != PF_INET) return EAI_FAMILY; + if (hints->ai_socktype && hints->ai_socktype != SOCK_STREAM && hints->ai_socktype != SOCK_DGRAM) return EAI_SOCKTYPE; + } + for (family=PF_INET6; ; family=PF_INET) { + if (!hints || hints->ai_family==family || hints->ai_family==AF_UNSPEC) { /* IPv6 addresses are OK */ + struct hostent h; + struct hostent *H; + int herrno=0; + char buf[4096]; + int lookupok=0; + h.h_addr_list=(char**)buf+16; + if (node) { + if (inet_pton(family,node,buf)>0) { + h.h_name=(char*)node; + h.h_addr_list[0]=buf; + lookupok=1; + } else if ((!hints || !(hints->ai_flags&AI_NUMERICHOST)) && + !gethostbyname2_r(node,family,&h,buf,4096,&H,&herrno)) { + lookupok=1; + } else { + if (herrno==TRY_AGAIN) { freeaddrinfo(*res); return EAI_AGAIN; } + } + } else { + h.h_name=0; + h.h_addr_list[0]=buf; + memset(buf,0,16); + if (!hints || !(hints->ai_flags&AI_PASSIVE)) { + if (family==AF_INET) { + buf[0]=127; buf[3]=1; + } else + buf[15]=1; + } + lookupok=1; + } + if (lookupok) { + struct ai_v6 { + struct addrinfo ai; + union { + struct sockaddr_in6 ip6; + struct sockaddr_in ip4; + } ip; + char name[1]; + } *foo; + unsigned short port; + int len=sizeof(struct ai_v6)+(h.h_name?strlen(h.h_name):0); + if (!(foo=malloc(len))) goto error; + foo->ai.ai_next=0; + foo->ai.ai_socktype=SOCK_STREAM; + foo->ai.ai_protocol=IPPROTO_TCP; + foo->ai.ai_addrlen=family==PF_INET6?sizeof(struct sockaddr_in6):sizeof(struct sockaddr_in); + foo->ai.ai_addr=(struct sockaddr*)&foo->ip; + if (family==PF_INET6) { + memset(&foo->ip,0,sizeof(foo->ip)); + memmove(&foo->ip.ip6.sin6_addr,h.h_addr_list[0],16); + } else { + memmove(&foo->ip.ip4.sin_addr,h.h_addr_list[0],4); + } + foo->ip.ip6.sin6_family=foo->ai.ai_family=family; + if (h.h_name) { + foo->ai.ai_canonname=foo->name; + memmove(foo->name,h.h_name,strlen(h.h_name)+1); + } else + foo->ai.ai_canonname=0; + if (!hints || hints->ai_socktype!=SOCK_DGRAM) { /* TCP is OK */ + char *x; + port=htons(strtol(service?service:"0",&x,0)); + if (*x) { /* service is not numeric :-( */ + struct servent* se; + if ((se=getservbyname(service,"tcp"))) { /* found a service. */ + port=se->s_port; + blah1: + if (family==PF_INET6) + foo->ip.ip6.sin6_port=port; + else + foo->ip.ip4.sin_port=port; + if (!*tmp) *tmp=&(foo->ai); else (*tmp)->ai_next=&(foo->ai); + if (!(foo=malloc(len))) goto error; + memmove(foo,*tmp,len); + tmp=&(*tmp)->ai_next; + foo->ai.ai_addr=(struct sockaddr*)&foo->ip; + if (foo->ai.ai_canonname) + foo->ai.ai_canonname=foo->name; + } else { + freeaddrinfo(*res); + return EAI_SERVICE; + } + } else goto blah1; + } + foo->ai.ai_socktype=SOCK_DGRAM; + foo->ai.ai_protocol=IPPROTO_UDP; + if (!hints || hints->ai_socktype!=SOCK_STREAM) { /* UDP is OK */ + char *x; + port=htons(strtol(service?service:"0",&x,0)); + if (*x) { /* service is not numeric :-( */ + struct servent* se; + if ((se=getservbyname(service,"udp"))) { /* found a service. */ + port=se->s_port; + blah2: + if (family==PF_INET6) + foo->ip.ip6.sin6_port=port; + else + foo->ip.ip4.sin_port=port; + if (!*tmp) *tmp=&(foo->ai); else (*tmp)->ai_next=&(foo->ai); + if (!(foo=malloc(len))) goto error; + memmove(foo,*tmp,len); + tmp=&(*tmp)->ai_next; + foo->ai.ai_addr=(struct sockaddr*)&foo->ip; + foo->ai.ai_canonname=foo->name; + } else { + freeaddrinfo(*res); + return EAI_SERVICE; + } + } else goto blah2; + } + free(foo); + } + } + if (family==PF_INET) break; + } + if (*res==0) return EAI_NONAME; /* kludge kludge... */ + return 0; +error: + freeaddrinfo(*res); + return EAI_MEMORY; +} diff --git a/mdk-stage1/dietlibc/libugly/gethostent.c b/mdk-stage1/dietlibc/libugly/gethostent.c new file mode 100644 index 000000000..fe92beacf --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/gethostent.c @@ -0,0 +1,116 @@ +#include <unistd.h> +#include <fcntl.h> +#include <netdb.h> +#include <sys/mman.h> +#include <errno.h> +#include <netinet/in.h> +#include <string.h> +#include <ctype.h> +#include <netdb.h> +#include <sys/socket.h> +#include <arpa/inet.h> +#include "dietfeatures.h" + +static char* hostmap=0; +static unsigned int hostlen; + +static char *cur; + +/* ::1 localhost6 alias1 alias2 # internet protocol, pseudo protocol number */ +struct hostent* gethostent_r(char* buf, int len) { + char *dest; + struct hostent* pe=(struct hostent*)buf; + char* last; + char* max=buf+len; + int aliasidx; + if (!hostmap) { + int hostfd=open(_PATH_HOSTS,O_RDONLY); + if (hostfd<0) return 0; + hostlen=lseek(hostfd,0,SEEK_END); + hostmap=mmap(0,hostlen,PROT_READ|PROT_WRITE,MAP_PRIVATE,hostfd,0); + if ((long)hostmap==(-1)) { close(hostfd); hostmap=0; goto error; } + close(hostfd); hostfd=-1; + cur=hostmap; + } + last=hostmap+hostlen; +again: + if ((size_t)len<sizeof(struct hostent)+11*sizeof(char*)) goto nospace; + dest=buf+sizeof(struct hostent); + pe->h_name=0; + pe->h_aliases=(char**)dest; pe->h_aliases[0]=0; dest+=10*sizeof(char*); + pe->h_addr_list=(char**)dest; dest+=2*sizeof(char**); + if (cur>=last) return 0; + if (*cur=='#' || *cur=='\n') goto parseerror; + /* first, the ip number */ + pe->h_name=cur; + while (cur<last && !isspace(*cur)) cur++; + if (cur>=last) return 0; + if (*cur=='\n') goto parseerror; + { + char save=*cur; + *cur=0; + pe->h_addr_list[0]=dest; + pe->h_addr_list[1]=0; + if (max-dest<16) goto nospace; + if (inet_pton(AF_INET6,pe->h_name,dest)>0) { + pe->h_addrtype=AF_INET6; + pe->h_length=16; + dest+=16; + } else if (inet_pton(AF_INET,pe->h_name,dest)>0) { + pe->h_addrtype=AF_INET; + pe->h_length=4; + dest+=4; + } else { + *cur=save; + goto parseerror; + } + *cur=save; + } + ++cur; + /* now the aliases */ + for (aliasidx=0;aliasidx<9;++aliasidx) { + while (cur<last && isblank(*cur)) ++cur; + pe->h_aliases[aliasidx]=cur; + while (cur<last && !isspace(*cur)) ++cur; + { + char *from=pe->h_aliases[aliasidx]; + int len=cur-from; + if (max-dest<len+2) goto nospace; + pe->h_aliases[aliasidx]=dest; + memmove(dest,from,(size_t)(cur-from)); + dest+=len; + *dest=0; ++dest; + } + if (*cur=='\n') { ++cur; ++aliasidx; break; } + if (cur>=last || !isblank(*cur)) break; + cur++; + } + pe->h_aliases[aliasidx]=0; + pe->h_name=pe->h_aliases[0]; + pe->h_aliases++; + return pe; +parseerror: + while (cur<last && *cur!='\n') cur++; + cur++; + goto again; +nospace: + errno=ERANGE; + goto __error; +error: + errno=ENOMEM; +__error: + if (hostmap!=(char*)-1) munmap(hostmap,hostlen); + hostmap=(char*)-1; + return 0; +} + +void sethostent(int stayopen) { + (void)stayopen; + cur=hostmap; +} + +void endhostent(void) { + if (hostmap!=(char*)-1) munmap(hostmap,hostlen); + hostmap=0; +} + diff --git a/mdk-stage1/dietlibc/libugly/getmntent.c b/mdk-stage1/dietlibc/libugly/getmntent.c index 250a77b7f..1a1bdca24 100644 --- a/mdk-stage1/dietlibc/libugly/getmntent.c +++ b/mdk-stage1/dietlibc/libugly/getmntent.c @@ -5,11 +5,11 @@ struct mntent *getmntent(FILE *filep) { static struct mntent m; - char buf[1024]; + static char buf[1024]; do { char *tmp=buf; int num; - fgets(buf,1024,filep); + if (!fgets(buf,1024,filep)) return 0; /* "/dev/ide/host0/bus0/target0/lun0/part2 / reiserfs defaults 1 1" */ for (num=0; num<6; ++num) { switch (num) { @@ -17,12 +17,13 @@ struct mntent *getmntent(FILE *filep) { case 1: m.mnt_dir=tmp; break; case 2: m.mnt_type=tmp; break; case 3: m.mnt_opts=tmp; break; - case 4: m.mnt_freq=strtol(tmp,&tmp,0); if (*tmp!=' ') continue; break; + case 4: m.mnt_freq=strtol(tmp,&tmp,0); if (*tmp!=' ' && *tmp!='\t') continue; break; case 5: m.mnt_passno=strtol(tmp,&tmp,0); if (*tmp=='\n') return &m; break; } - if ((tmp=strchr(tmp,' '))) { + while (*tmp && *tmp!=' ' && *tmp!='\n' && *tmp!='\t') ++tmp; + if (*tmp) { if (num<4) *tmp++=0; - while (*tmp==' ') ++tmp; + while (*tmp==' ' || *tmp=='\t') ++tmp; } else continue; } diff --git a/mdk-stage1/dietlibc/libugly/getnameinfo.c b/mdk-stage1/dietlibc/libugly/getnameinfo.c new file mode 100644 index 000000000..40883ba09 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getnameinfo.c @@ -0,0 +1,46 @@ +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> +#include <arpa/inet.h> +#include <string.h> + +extern int __ltostr(char *s, int size, unsigned long i, int base, char UpCase); + +int getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, + size_t hostlen, char *serv, size_t servlen, int flags) { + sa_family_t f=((struct sockaddr_storage *)sa)->ss_family; + (void)salen; /* shut gcc up about unused salen */ + if (host && hostlen>0) { /* user wants me to resolve the host name */ + register const char*addr=(f==AF_INET6)?(char*)&((struct sockaddr_in6*)sa)->sin6_addr: + (char*)&((struct sockaddr_in*)sa)->sin_addr; + if (flags&NI_NUMERICHOST) { + if (!inet_ntop(f,addr,host,hostlen)) + return EAI_NONAME; + } else { + char buf[4096]; + struct hostent h; + struct hostent *H; + int herrno; + if (gethostbyaddr_r(addr,f==AF_INET6?16:4,f,&h,buf,4096,&H,&herrno)) { + switch (herrno) { + case TRY_AGAIN: return EAI_AGAIN; + case NO_DATA: + case HOST_NOT_FOUND: return EAI_NONAME; + } + } + strncpy(host,h.h_name,hostlen-1); + host[hostlen-1]=0; + } + } + if (serv && servlen>0) { + register short int port=(f==AF_INET6)?((struct sockaddr_in6*)sa)->sin6_port:((struct sockaddr_in*)sa)->sin_port; + if (flags&NI_NUMERICSERV) { + __ltostr(serv,servlen,ntohs(port),10,0); + } else { + struct servent *s; + if (!(s=getservbyport(port,flags&NI_DGRAM?"udp":"tcp"))) + return EAI_SERVICE; + } + } + return 0; +} diff --git a/mdk-stage1/dietlibc/libugly/getprotobyname.c b/mdk-stage1/dietlibc/libugly/getprotobyname.c new file mode 100644 index 000000000..1de348791 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getprotobyname.c @@ -0,0 +1,12 @@ +#include <string.h> +#include <netdb.h> + +extern struct protoent __protoent_pw; +extern char __protoent_buf[1000]; + +struct protoent *getprotobyname(const char *name) { + struct protoent* tmp; + if (getprotobyname_r(name,&__protoent_pw,__protoent_buf,sizeof(__protoent_buf),&tmp)==0) + return tmp; + return 0; +} diff --git a/mdk-stage1/dietlibc/libugly/getprotobyname_r.c b/mdk-stage1/dietlibc/libugly/getprotobyname_r.c new file mode 100644 index 000000000..3b1219aa7 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getprotobyname_r.c @@ -0,0 +1,17 @@ +#include <string.h> +#include <netdb.h> + +extern int getprotobyname_r(const char* name, + struct protoent *res, char *buf, size_t buflen, + struct protoent **res_sig) { + while (!getprotoent_r(res,buf,buflen,res_sig)) { + int i; + if (!strcmp(res->p_name,name)) goto found; + for (i=0; res->p_aliases[i]; ++i) + if (!strcmp(res->p_aliases[i],name)) goto found; + } + *res_sig=0; +found: + endprotoent(); + return *res_sig?0:-1; +} diff --git a/mdk-stage1/dietlibc/libugly/getprotobynumber.c b/mdk-stage1/dietlibc/libugly/getprotobynumber.c new file mode 100644 index 000000000..6170753e2 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getprotobynumber.c @@ -0,0 +1,12 @@ +#include <string.h> +#include <netdb.h> + +extern struct protoent __protoent_pw; +extern char __protoent_buf[1000]; + +struct protoent *getprotobynumber(int proto) { + struct protoent* tmp; + if (getprotobynumber_r(proto,&__protoent_pw,__protoent_buf,sizeof(__protoent_buf),&tmp)==0) + return tmp; + return 0; +} diff --git a/mdk-stage1/dietlibc/libugly/getprotobynumber_r.c b/mdk-stage1/dietlibc/libugly/getprotobynumber_r.c new file mode 100644 index 000000000..2ca439fc6 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getprotobynumber_r.c @@ -0,0 +1,13 @@ +#include <string.h> +#include <netdb.h> + +extern int getprotobynumber_r(int proto, + struct protoent *res, char *buf, size_t buflen, + struct protoent **res_sig) { + while (!getprotoent_r(res,buf,buflen,res_sig)) + if (proto==res->p_proto) goto found; + *res_sig=0; +found: + endprotoent(); + return *res_sig?0:-1; +} diff --git a/mdk-stage1/dietlibc/libugly/getprotoent.c b/mdk-stage1/dietlibc/libugly/getprotoent.c index a648e2307..3f0fd4d41 100644 --- a/mdk-stage1/dietlibc/libugly/getprotoent.c +++ b/mdk-stage1/dietlibc/libugly/getprotoent.c @@ -1,130 +1,10 @@ -#include <unistd.h> -#include <fcntl.h> #include <netdb.h> -#include <sys/mman.h> -#include <errno.h> -#include <netinet/in.h> -#include <string.h> -#include <ctype.h> -static int protofd=-1; -static char* protomap; -static unsigned int protolen; +extern struct protoent __protoent_pw; +extern char __protoent_buf[1000]; -static char* aliases[10]; - -static char *cur; - -/* ip 0 IP # internet protocol, pseudo protocol number */ struct protoent *getprotoent(void) { - static struct protoent pe; - char *last; - int aliasidx; - if (protofd<0) { - protofd=open(_PATH_SERVICES,O_RDONLY); - if (protofd<0) return 0; - protolen=lseek(protofd,0,SEEK_END); - protomap=mmap(0,protolen,PROT_READ|PROT_WRITE,MAP_PRIVATE,protofd,0); - if ((long)protomap==(-1)) goto error; - cur=protomap; - } - last=protomap+protolen; -again: - pe.p_name=0; - pe.p_aliases=aliases; aliases[0]=0; - pe.p_proto=0; - if (cur>=last) return 0; - if (*cur=='#' || *cur=='\n') goto parseerror; - /* first, the primary name */ - if (!isalpha(*cur)) goto parseerror; - pe.p_name=cur; - pe.p_aliases=aliases; - while (cur<last && isalnum(*cur)) cur++; - if (cur>=last) return 0; - if (*cur=='\n') goto parseerror; - *cur=0; cur++; - /* second, the protocol number */ - while (cur<last && isblank(*cur)) cur++; - while (cur<last && isdigit(*cur)) { - pe.p_proto=pe.p_proto*10+*cur-'0'; - cur++; - } -/* pe.p_proto=htons(pe.s_proto); */ - if (cur>=last) return 0; - if (*cur=='\n') { *cur++=0; return &pe; } - *cur=0; cur++; - /* now the aliases */ - for (aliasidx=0;aliasidx<10;++aliasidx) { - while (cur<last && isblank(*cur)) ++cur; - aliases[aliasidx]=cur; - while (cur<last && isalpha(*cur)) ++cur; - if (*cur=='\n') { *cur++=0; ++aliasidx; break; } - if (cur>=last || !isblank(*cur)) break; - *cur++=0; - } - aliases[aliasidx]=0; - return &pe; -parseerror: - while (cur<last && *cur!='\n') cur++; - cur++; - goto again; -error: - if (protomap!=(char*)-1) munmap(protomap,protolen); - if (protofd!=-1) close(protofd); - protomap=(char*)-1; - protofd=-1; - errno=ENOMEM; - return 0; -} - -void setprotoent(int stayopen) { - cur=protomap; -} - -struct protoent *getprotobyname(const char *name) { - struct protoent *s; - setprotoent(0); - for (s=getprotoent(); s; s=getprotoent()) { - char **tmp; -#if 0 - write(1,"found ",6); - write(1,s->p_name,strlen(s->p_name)); - write(1,"/",1); - write(1,s->p_proto,strlen(s->p_proto)); - write(1,"\n",1); - if (!strcmp(name,"auth")) { - tmp=s->p_aliases; - write(1," aka ",5); - while (*tmp) { - write(1,*tmp,strlen(*tmp)); - write(1,", ",2); - ++tmp; - } - write(1,"\n",1); - } -#endif - if (!strcmp(name,s->p_name)) - return s; - tmp=s->p_aliases; - while (*tmp) - if (!strcmp(name,*tmp++)) return s; - } - return 0; + struct protoent* tmp; + getprotoent_r(&__protoent_pw,__protoent_buf,sizeof(__protoent_buf),&tmp); + return tmp; } - -struct protoent *getprotobynumber(int proto) { - struct protoent *s; - for (s=getprotoent(); s; s=getprotoent()) { - if (proto==s->p_proto) - return s; - } - return 0; -} - -void endprotoent(void) { - if (protomap!=(char*)-1) munmap(protomap,protolen); - if (protofd!=-1) close(protofd); - protomap=(char*)-1; - protofd=-1; -} - diff --git a/mdk-stage1/dietlibc/libugly/getprotoent_r.c b/mdk-stage1/dietlibc/libugly/getprotoent_r.c new file mode 100644 index 000000000..aa9af79c3 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getprotoent_r.c @@ -0,0 +1,78 @@ +#include <string.h> +#include <sys/types.h> +#include <sys/mman.h> +#include <netdb.h> +#include <ctype.h> +#include "parselib.h" + +static struct state __ps; + +void setprotoent(int stayopen) { + (void)stayopen; + __prepare_parse(_PATH_PROTOCOLS,&__ps); +} + +void endprotoent(void) { + __end_parse(&__ps); +} + +#define ALIASES 16 + +/* "igmp 2 IGMP # internet group management protocol" */ +int getprotoent_r(struct protoent *res, char *buf, size_t buflen, + struct protoent **res_sig) { + size_t i,j,n,g; + unsigned long l; + if (!__ps.buffirst) setprotoent(0); + if (!__ps.buffirst) goto error; + if (__ps.cur>=__ps.buflen) goto error; + res->p_aliases=(char**)buf; +/* getprotoent */ +again: + n=ALIASES*sizeof(char*); g=0; + for (i=0; i<3; ++i) { + char found; + __ps.cur+=__parse_ws(&__ps); + if (__ps.cur>=__ps.buflen) { if (i==2) break; else goto error; } + j=__parse_nws(&__ps); + if (!isblank(found=__ps.buffirst[__ps.cur+j])) { + if (i==2) break; /* it's ok, no (more) aliases necessary */ +parseerror: + while (__ps.cur+j<__ps.buflen) { + if (__ps.buffirst[__ps.cur+j]=='\n') { + __ps.cur+=j+1; + goto again; + } + ++j; + } + } + switch (i) { + case 0: + res->p_name=buf+n; +copy: + if ((size_t)buflen<=n+j) goto error; + memcpy(buf+n,__ps.buffirst+__ps.cur,j); + buf[n+j]=0; + n+=j+1; + if ((found=='\n' || found=='#') && i==1) i=3; + break; + case 1: + if (scan_ulong(__ps.buffirst+__ps.cur,&l)!=j) goto parseerror; + res->p_proto=l; + break; + case 2: + res->p_aliases[g]=buf+n; + ++g; + if (g==(ALIASES-1)) break; + --i; /* again */ + goto copy; + } + __ps.cur+=j+1; + } + res->p_aliases[g]=0; + *res_sig=res; + return 0; +error: + *res_sig=0;/* the glibc people should be taken behind the barn and shot */ + return -1; +} diff --git a/mdk-stage1/dietlibc/libugly/getservbyname.c b/mdk-stage1/dietlibc/libugly/getservbyname.c new file mode 100644 index 000000000..f1c74eaa9 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getservbyname.c @@ -0,0 +1,12 @@ +#include <string.h> +#include <netdb.h> + +extern struct servent __servent_pw; +extern char __servent_buf[1000]; + +struct servent *getservbyname(const char *name, const char *proto) { + struct servent* tmp; + if (getservbyname_r(name,proto,&__servent_pw,__servent_buf,sizeof(__servent_buf),&tmp)==0) + return tmp; + return 0; +} diff --git a/mdk-stage1/dietlibc/libugly/getservbyname_r.c b/mdk-stage1/dietlibc/libugly/getservbyname_r.c new file mode 100644 index 000000000..f523a01ca --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getservbyname_r.c @@ -0,0 +1,18 @@ +#include <string.h> +#include <netdb.h> + +extern int getservbyname_r(const char* name,const char* proto, + struct servent *res, char *buf, size_t buflen, + struct servent **res_sig) { + while (!getservent_r(res,buf,buflen,res_sig)) { + int i; + if (proto && strcmp(res->s_proto,proto)) continue; + if (!strcmp(res->s_name,name)) goto found; + for (i=0; res->s_aliases[i]; ++i) + if (!strcmp(res->s_aliases[i],name)) goto found; + } + *res_sig=0; +found: + endservent(); + return *res_sig?0:-1; +} diff --git a/mdk-stage1/dietlibc/libugly/getservbyport.c b/mdk-stage1/dietlibc/libugly/getservbyport.c new file mode 100644 index 000000000..2821deb63 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getservbyport.c @@ -0,0 +1,12 @@ +#include <string.h> +#include <netdb.h> + +extern struct servent __servent_pw; +extern char __servent_buf[1000]; + +struct servent *getservbyport(int port, const char *proto) { + struct servent* tmp; + if (getservbyport_r(port,proto,&__servent_pw,__servent_buf,sizeof(__servent_buf),&tmp)==0) + return tmp; + return 0; +} diff --git a/mdk-stage1/dietlibc/libugly/getservbyport_r.c b/mdk-stage1/dietlibc/libugly/getservbyport_r.c new file mode 100644 index 000000000..9c0f21bdf --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getservbyport_r.c @@ -0,0 +1,13 @@ +#include <string.h> +#include <netdb.h> + +extern int getservbyport_r(int port,const char* proto, + struct servent *res, char *buf, size_t buflen, + struct servent **res_sig) { + while (!getservent_r(res,buf,buflen,res_sig)) + if (port==res->s_port && !strcmp(res->s_proto,proto)) goto ok; + *res_sig=0; +ok: + endservent(); + return *res_sig?0:-1; +} diff --git a/mdk-stage1/dietlibc/libugly/getservent.c b/mdk-stage1/dietlibc/libugly/getservent.c new file mode 100644 index 000000000..9eabc972a --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getservent.c @@ -0,0 +1,10 @@ +#include <netdb.h> + +extern struct servent __servent_pw; +extern char __servent_buf[1000]; + +struct servent *getservent(void) { + struct servent* tmp; + getservent_r(&__servent_pw,__servent_buf,sizeof(__servent_buf),&tmp); + return tmp; +} diff --git a/mdk-stage1/dietlibc/libugly/getservent_r.c b/mdk-stage1/dietlibc/libugly/getservent_r.c new file mode 100644 index 000000000..33db6f31d --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/getservent_r.c @@ -0,0 +1,91 @@ +#include <sys/types.h> +#include <sys/mman.h> +#include <netinet/in.h> +#include <string.h> +#include <netdb.h> +#include <ctype.h> +#include "parselib.h" + +static struct state __ps; + +void setservent(int stayopen) { + (void)stayopen; + __prepare_parse(_PATH_SERVICES,&__ps); +} + +void endservent(void) { + __end_parse(&__ps); +} + +#define ALIASES 16 + +/* "tcpmux 1/tcp # TCP port multiplexer (RFC1078)" */ +int getservent_r(struct servent *res, char *buf, size_t buflen, + struct servent **res_sig) { + size_t i,j,n,g; + unsigned long l; + if (!__ps.buffirst) setservent(0); + if (!__ps.buffirst) goto error; + if (__ps.cur>=__ps.buflen) goto error; + res->s_aliases=(char**)buf; +/* getservent */ +again: + n=ALIASES*sizeof(char*); g=0; + for (i=0; i<3; ++i) { + char found; + __ps.cur+=__parse_ws(&__ps); + if (__ps.cur>=__ps.buflen) { if (i==2) break; else goto error; } + j=__parse_nws(&__ps); + if (!isblank(found=__ps.buffirst[__ps.cur+j])) { + if (i==2 && found=='#') break; + if (found=='#' || (i>1 && found!='\n')) { +parseerror: + while (__ps.cur+j<__ps.buflen) { + if (__ps.buffirst[__ps.cur+j]=='\n') { + __ps.cur+=j+1; + goto again; + } + ++j; + } + goto error; + } + } + switch (i) { + case 0: + res->s_name=buf+n; +copy: + if (!j) goto parseerror; + if ((size_t)buflen<=n+j) goto error; + memcpy(buf+n,__ps.buffirst+__ps.cur,j); + buf[n+j]=0; + n+=j+1; + if ((found=='\n' || found=='#') && i==1) i=3; + break; + case 1: + { + int k; + k=scan_ulong(__ps.buffirst+__ps.cur,&l); + if (__ps.buffirst[__ps.cur+k]!='/') { + goto parseerror; + } + res->s_port=htons(l); + res->s_proto=buf+n; + j-=k+1; __ps.cur+=k+1; + goto copy; + } + case 2: + res->s_aliases[g]=buf+n; + ++g; + if (g==(ALIASES-1)) break; + --i; /* again */ + goto copy; + } + __ps.cur+=j+1; + } + res->s_aliases[g]=0; + *res_sig=res; + return 0; +error: + *res_sig=0;/* the glibc people should be taken behind the barn and shot */ + return -1; +} diff --git a/mdk-stage1/dietlibc/libugly/gmtime_r.c b/mdk-stage1/dietlibc/libugly/gmtime_r.c index c102d10fa..6bc0bb5b2 100644 --- a/mdk-stage1/dietlibc/libugly/gmtime_r.c +++ b/mdk-stage1/dietlibc/libugly/gmtime_r.c @@ -3,7 +3,7 @@ /* seconds per day */ #define SPD 24*60*60 -extern unsigned int __spm[]; +extern short __spm[]; struct tm *gmtime_r(const time_t *timep, struct tm *r) { time_t i; @@ -14,7 +14,7 @@ struct tm *gmtime_r(const time_t *timep, struct tm *r) { r->tm_wday=(4+work)%7; for (i=1970; ; ++i) { register time_t k=__isleap(i)?366:365; - if (work>k) + if (work>=k) work-=k; else break; @@ -28,7 +28,7 @@ struct tm *gmtime_r(const time_t *timep, struct tm *r) { work-=1; } - for (i=11; i && __spm[i]>work; --i) ; + for (i=11; i && (__spm[i]>work); --i) ; r->tm_mon=i; r->tm_mday+=work-__spm[i]; return r; diff --git a/mdk-stage1/dietlibc/libugly/grantpt.c b/mdk-stage1/dietlibc/libugly/grantpt.c new file mode 100644 index 000000000..0aa903b29 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/grantpt.c @@ -0,0 +1,13 @@ +#define _XOPEN_SOURCE +#include <unistd.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <stdlib.h> + +int grantpt (int fd) { + struct stat st; + if ((fstat(fd, &st))<0) return -1; + if ((chmod((char*)ptsname(fd), st.st_mode | S_IRUSR | S_IWUSR | S_IWGRP))<0) + return -1; + return 0; +} diff --git a/mdk-stage1/dietlibc/libugly/hasmntopt.c b/mdk-stage1/dietlibc/libugly/hasmntopt.c new file mode 100644 index 000000000..2a547feee --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/hasmntopt.c @@ -0,0 +1,18 @@ +#include <string.h> +#include <mntent.h> + +char *hasmntopt(const struct mntent *mnt, const char *opt) { + char *s=mnt->mnt_opts; + char *c; + int len=strlen(opt); + if (!s) return 0; + for (c=s;;) { + if (!(c=strstr(c,opt))) break; + if (c==s || c[-1]==',') { + if (c[len]==0 || c[len]==',' || c[len]=='=') + return c; + } + c+=len+1; + } + return 0; +} diff --git a/mdk-stage1/dietlibc/libugly/iconv.c b/mdk-stage1/dietlibc/libugly/iconv.c new file mode 100644 index 000000000..45be5d91d --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/iconv.c @@ -0,0 +1,71 @@ +#include "dietfeatures.h" +#include <errno.h> +#include "dieticonv.h" +#include <netinet/in.h> + +size_t iconv(iconv_t cd, const char* * inbuf, size_t * + inbytesleft, char* * outbuf, size_t * outbytesleft) { + size_t converted=0,i,j,k; + int bits; + if (!inbuf || !*inbuf) return 0; + while (*inbytesleft) { + unsigned int v=0; + v=*(unsigned char*)*inbuf; + i=j=1; + switch (ic_from(cd)) { + case UCS_2: + v=ntohs(*(unsigned short*)*inbuf); + i=2; + break; + case UCS_4: + v=ntohs(*(unsigned int*)*inbuf); + i=4; + case ISO_8859_1: + break; + case UTF_8: + if (!(v&0x80)) break; + for (i=0xC0; i!=0xFC; i=(i>>1)+0x80) + if ((v&((i>>1)|0x80))==i) { + v&=~i; + break; + } + for (i=1; ((*inbuf)[i]&0xc0)==0x80; ++i) + v=(v<<6)|((*inbuf)[i]&0x3f); +/* printf("got %u in %u bytes, buflen %u\n",v,i,*inbytesleft); */ + break; + } + switch (ic_to(cd)) { + case ISO_8859_1: + **outbuf=(unsigned char)v; + break; + case UCS_2: + *(unsigned short*)*outbuf=htons(v); + j=2; + break; + case UCS_4: + *(unsigned int*)*outbuf=htonl(v); + j=4; + break; + case UTF_8: + if (v>0x04000000) { bits=30; **outbuf=0xFC; j=6; } else + if (v>0x00200000) { bits=24; **outbuf=0xF8; j=5; } else + if (v>0x00010000) { bits=18; **outbuf=0xF0; j=4; } else + if (v>0x00000800) { bits=12; **outbuf=0xE0; j=3; } else + if (v>0x00000080) { bits=6; **outbuf=0xC0; j=2; } else + { bits=0; **outbuf=0; } + **outbuf |= (unsigned char)(v>>bits); + if (*outbytesleft<j) { + errno=E2BIG; + return (size_t)-1; + } + for (k=1; k<j; ++k) { + bits-=6; + (*outbuf)[k]=0x80+((v>>bits)&0x3F); + } + break; + } + *inbuf+=i; *inbytesleft-=i; ++converted; + *outbuf+=j; *outbytesleft-=j; + } + return converted; +} diff --git a/mdk-stage1/dietlibc/libugly/iconv_close.c b/mdk-stage1/dietlibc/libugly/iconv_close.c new file mode 100644 index 000000000..7d5d4c4b9 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/iconv_close.c @@ -0,0 +1,7 @@ +#include <stdlib.h> +#include "dieticonv.h" + +int iconv_close(iconv_t cd) { + (void)cd; /* shut gcc up about unused cd */ + return 0; +} diff --git a/mdk-stage1/dietlibc/libugly/iconv_open.c b/mdk-stage1/dietlibc/libugly/iconv_open.c new file mode 100644 index 000000000..eabab4273 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/iconv_open.c @@ -0,0 +1,28 @@ +#include <string.h> +#include <strings.h> +#include "dietfeatures.h" +#include <errno.h> +#include <stdlib.h> +#include "dieticonv.h" + +static enum charset parsecharset(const char* s) { + if (!strcasecmp(s,"UTF-8")) return UTF_8; else + if (!strcasecmp(s,"UCS-2") || !strcasecmp(s,"UCS2")) return UCS_2; else + if (!strcasecmp(s,"UCS-4") || !strcasecmp(s,"UCS4")) return UCS_4; else + if (!strcasecmp(s,"ISO-8859-1")) return ISO_8859_1; else + if (!strcasecmp(s,"US-ASCII")) return ISO_8859_1; else + return INVALID; +} + +iconv_t iconv_open(const char* tocode, const char* fromcode) { + int f,t; + + f=parsecharset(fromcode); + t=parsecharset(tocode); + + if (f==INVALID || t==INVALID) { + errno=EINVAL; + return (iconv_t)(-1); + } + return (f|t<<16); +} diff --git a/mdk-stage1/dietlibc/libugly/isleap.c b/mdk-stage1/dietlibc/libugly/isleap.c index dcfa1ced6..d83712792 100644 --- a/mdk-stage1/dietlibc/libugly/isleap.c +++ b/mdk-stage1/dietlibc/libugly/isleap.c @@ -1,3 +1,5 @@ +#include <time.h> + int __isleap(int year) { /* every fourth year is a leap year except for century years that are * not divisible by 400. */ diff --git a/mdk-stage1/dietlibc/libugly/localtime_r.c b/mdk-stage1/dietlibc/libugly/localtime_r.c index d4bc073ce..5d420303c 100644 --- a/mdk-stage1/dietlibc/libugly/localtime_r.c +++ b/mdk-stage1/dietlibc/libugly/localtime_r.c @@ -3,8 +3,11 @@ #include <sys/time.h> #ifdef WANT_TZFILE_PARSER -extern void __maplocaltime(); +extern void __maplocaltime(void); extern time_t __tzfile_map(time_t t, int *isdst); +#else +extern long int timezone; +extern int daylight; #endif struct tm* localtime_r(const time_t* t, struct tm* r) { @@ -15,7 +18,8 @@ struct tm* localtime_r(const time_t* t, struct tm* r) { #else struct timezone tz; gettimeofday(0, &tz); - tmp=*t-tz.tz_minuteswest*60L; + timezone=tz.tz_minuteswest*60L; + tmp=*t+timezone; #endif return gmtime_r(&tmp,r); } diff --git a/mdk-stage1/dietlibc/libugly/logging.c b/mdk-stage1/dietlibc/libugly/logging.c index 69c2c2337..680a1f850 100644 --- a/mdk-stage1/dietlibc/libugly/logging.c +++ b/mdk-stage1/dietlibc/libugly/logging.c @@ -1,3 +1,4 @@ +#include <errno.h> #include "dietfeatures.h" #include <stdio.h> @@ -5,7 +6,6 @@ #include <stdarg.h> #include <errno.h> #include <unistd.h> -#include <asm/socket.h> #include <fcntl.h> #include <syslog.h> #include <string.h> @@ -14,9 +14,9 @@ #include <signal.h> #define _PATH_CONSOLE "/dev/console" -#define BUF_SIZE 512 /* messagebuffer size (>= 200) */ +#define BUF_SIZE 2048 /* messagebuffer size (>= 200) */ -#define MAX_LOGTAG 80 +#define MAX_LOGTAG 1000 /* those have to be global *sigh* */ static volatile int connected = 0; /* have done connect */ @@ -37,13 +37,15 @@ static void closelog_intern(void) connected = 0; } -void closelog(void) +void __libc_closelog(void); +void __libc_closelog(void) { closelog_intern(); LogTag[0]=0; LogType = SOCK_DGRAM; } +void closelog(void) __attribute__((weak,alias("__libc_closelog"))); static void openlog_intern(int option, int facility) { @@ -63,27 +65,15 @@ static void openlog_intern(int option, int facility) } } if ((LogFile != -1) && !connected) { -#ifdef WANT_THREAD_SAFE - int old_errno = (*(__errno_location())); -#else int old_errno=errno; -#endif if(connect(LogFile, &SyslogAddr, sizeof(SyslogAddr)) == -1) { -#ifdef WANT_THREAD_SAFE - int saved_errno = (*(__errno_location())); -#else int saved_errno=errno; -#endif close(LogFile); LogFile = -1; if((LogType == SOCK_DGRAM) && (saved_errno == EPROTOTYPE)) { /* retry with SOCK_STREAM instead of SOCK_DGRAM */ LogType = SOCK_STREAM; -#ifdef WANT_THREAD_SAFE - (*(__errno_location()))=old_errno; -#else errno=old_errno; -#endif continue; } } @@ -94,7 +84,8 @@ static void openlog_intern(int option, int facility) } /* has to be secured against multiple, simultanious call's in threaded environment */ -void openlog(const char *ident, int option, int facility) +void __libc_openlog(const char *ident, int option, int facility); +void __libc_openlog(const char *ident, int option, int facility) { if (ident) { strncpy(LogTag,ident,MAX_LOGTAG); @@ -102,6 +93,7 @@ void openlog(const char *ident, int option, int facility) } openlog_intern(option, facility); } +void openlog(const char *ident, int option, int facility) __attribute__((weak,alias("__libc_openlog"))); int setlogmask(int mask) { @@ -110,7 +102,8 @@ int setlogmask(int mask) return old; } -void vsyslog(int priority, const char *format, va_list arg_ptr) +void __libc_vsyslog(int priority, const char *format, va_list arg_ptr); +void __libc_vsyslog(int priority, const char *format, va_list arg_ptr) { char buffer[BUF_SIZE]; char time_buf[20]; @@ -122,11 +115,7 @@ void vsyslog(int priority, const char *format, va_list arg_ptr) int sigpipe; struct sigaction action, oldaction; struct sigaction *oldaction_ptr = NULL; -#ifdef WANT_THREAD_SAFE - int saved_errno = (*(__errno_location())); -#else int saved_errno = errno; -#endif /* check for invalid priority/facility bits */ if (priority & ~(LOG_PRIMASK|LOG_FACMASK)) { @@ -156,11 +145,7 @@ void vsyslog(int priority, const char *format, va_list arg_ptr) buflen = 41; } else { -#ifdef WANT_THREAD_SAFE - (*(__errno_location()))=saved_errno; -#else errno=saved_errno; -#endif buflen = vsnprintf(buffer+headerlen, BUF_SIZE - headerlen, format, arg_ptr); } if (LogStat & LOG_PERROR) { @@ -201,6 +186,7 @@ void vsyslog(int priority, const char *format, va_list arg_ptr) if (sigpipe == 0) sigaction(SIGPIPE, &oldaction, (struct sigaction *) NULL); } +void vsyslog(int priority, const char *format, va_list arg_ptr) __attribute__((weak,alias("__libc_vsyslog"))); void syslog(int priority, const char *format, ...) { diff --git a/mdk-stage1/dietlibc/libugly/mktime.c b/mdk-stage1/dietlibc/libugly/mktime.c index ee4dab6c1..348068e1d 100644 --- a/mdk-stage1/dietlibc/libugly/mktime.c +++ b/mdk-stage1/dietlibc/libugly/mktime.c @@ -1,21 +1,53 @@ #include <time.h> -/* seconds per day */ -#define SPD 24*60*60 - -extern unsigned int __spm[]; - -time_t mktime(struct tm *t) { - time_t x=0; - unsigned int i; - if (t->tm_year<70) return (time_t)(-1); - for (i=70; i<t->tm_year; ++i) { - x+=__isleap(i+1900)?366:365; - } - t->tm_yday=__spm[t->tm_mon] + t->tm_mday-1 + ((t->tm_mon>2) && __isleap(t->tm_year)?1:0); - x+=t->tm_yday; - /* x is now the number of days since Jan 1 1970 */ - t->tm_wday=(4+x)%7; - x = x*SPD + t->tm_hour*60*60 + t->tm_min*60 + t->tm_sec; - return x; +extern const short __spm []; + +time_t mktime ( register struct tm* const t ) +{ + register time_t day; + register time_t i; + + if ( t->tm_year < 70 ) + return (time_t) -1; + + day = t->tm_yday = __spm [t->tm_mon] + t->tm_mday-1 + ( __isleap (t->tm_year+1900) & (t->tm_mon > 1) ); + + for ( i = 70; i < t->tm_year; i++ ) + day += 365 + __isleap (i+1900); + + /* day is now the number of days since 'Jan 1 1970' */ + i = 7; + t->tm_wday = (day + 4) % i; /* Sunday=0, Monday=1, ..., Saturday=6 */ + + i = 24; + day *= i; + i = 60; + return ((day + t->tm_hour) * i + t->tm_min) * i + t->tm_sec; +} + +#if 0 + +#include <math.h> + +main() +{ + int i, j, k; + static char *s[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; + + for (i=70; i<200; i++) + for (j=0; j<12; j++) + for (k=1; k<=31; k++) { + struct tm t; + double x; + t.tm_year = i; + t.tm_mon = j; + t.tm_mday = k; + t.tm_hour = 0; + t.tm_min = 0; + t.tm_sec = 0; + x = mktime (&t); + printf ("%4d.%5.0f %2u.%02u.%04u %s\n", (int)floor(x/86400), x-86400.*(int)floor(x/86400), k, j+1, 1900+i, s[t.tm_wday] ); + } + } +#endif diff --git a/mdk-stage1/dietlibc/libugly/netent.c b/mdk-stage1/dietlibc/libugly/netent.c new file mode 100644 index 000000000..4710d0fe6 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/netent.c @@ -0,0 +1,130 @@ +#include <unistd.h> +#include <fcntl.h> +#include <sys/mman.h> +#include <errno.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <string.h> +#include <ctype.h> +#include "dietfeatures.h" +#include <netdb.h> +#include <arpa/inet.h> + +static int netfd=-1; +static char* netmap; +static unsigned int netlen; + +static char* aliases[10]; + +static char *cur; + +/* loopback 127.0.0.0 lo # comment */ +struct netent *getnetent(void) { + static struct netent ne; + char *last; + int aliasidx; + if (netfd<0) { + netfd=open(_PATH_NETWORKS,O_RDONLY); + if (netfd<0) return 0; + fcntl (netfd, F_SETFD, FD_CLOEXEC); + netlen=lseek(netfd,0,SEEK_END); + netmap=mmap(0,netlen,PROT_READ|PROT_WRITE,MAP_PRIVATE,netfd,0); + if ((long)netmap==(-1)) goto error; + cur=netmap; + } + last=netmap+netlen; +again: + ne.n_name=0; + ne.n_aliases=aliases; aliases[0]=0; + ne.n_addrtype=AF_INET; + ne.n_net=0; + if (cur>=last) return 0; + if (*cur=='#' || *cur=='\n') goto parseerror; + /* first, the primary name */ + if (!isalpha(*cur)) goto parseerror; + ne.n_name=cur; + ne.n_aliases=aliases; + while (cur<last && isalnum(*cur)) cur++; + if (cur>=last) return 0; + if (*cur=='\n') goto parseerror; + *cur=0; cur++; + /* second, the ip */ + while (cur<last && isblank(*cur)) cur++; + { + const char *tmp=cur; + char save; + while (cur<last && (isdigit(*cur) || *cur=='.')) ++cur; + save=*cur; *cur=0; + if (inet_aton(tmp,(struct in_addr*)&ne.n_net)==0) goto parseerror; + *cur=save; + } + if (cur>=last) return 0; + /* now the aliases */ + for (aliasidx=0;aliasidx<10;++aliasidx) { + while (cur<last && isblank(*cur)) ++cur; + aliases[aliasidx]=cur; + while (cur<last && isalpha(*cur)) ++cur; + if (*cur=='\n') { *cur++=0; ++aliasidx; break; } + if (cur>=last || !isblank(*cur)) break; + *cur++=0; + } + aliases[aliasidx]=0; + return ≠ +parseerror: + while (cur<last && *cur!='\n') cur++; + cur++; + goto again; +error: + if (netmap!=(char*)-1) munmap(netmap,netlen); + if (netfd!=-1) close(netfd); + netmap=(char*)-1; + netfd=-1; + errno=ENOMEM; + return 0; +} + +struct netent *getnetbyaddr(unsigned long net, int type) { + struct netent *s; + for (s=getnetent(); s; s=getnetent()) { + if (net==s->n_net && type==s->n_addrtype) + return s; + } + return 0; +} + +void endnetent(void) { + if (netmap!=(char*)-1) munmap(netmap,netlen); + if (netfd!=-1) close(netfd); + netmap=(char*)-1; + netfd=-1; +} + +void setnetent(int stayopen) { + (void)stayopen; + endnetent(); +} + +struct netent *getnetbyname(const char *name) { + struct netent *s; + setnetent(0); + for (s=getnetent(); s; s=getnetent()) { + char **tmp; +#if 0 + write(1,"found ",6); + write(1,s->s_name,strlen(s->s_name)); + write(1,"/",1); + write(1,s->s_proto,strlen(s->s_proto)); + write(1,"\n",1); + if (!strcmp(s->s_name,"ssh")) { + write(2,"ssh!\n",5); + } +#endif + if (!strcmp(name,s->n_name)) + return s; + tmp=s->n_aliases; + while (*tmp) + if (!strcmp(name,*tmp++)) return s; + } + return 0; +} + diff --git a/mdk-stage1/dietlibc/libugly/openpty.c b/mdk-stage1/dietlibc/libugly/openpty.c new file mode 100644 index 000000000..8d06f329c --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/openpty.c @@ -0,0 +1,54 @@ +#include <unistd.h> +#include <pty.h> +#include <fcntl.h> +#include <termios.h> +#include <sys/ioctl.h> +#include <errno.h> +#include <string.h> + +extern int __ltostr(char *s, int size, unsigned long i, int base, char UpCase); + +int openpty(int *amaster, int *aslave, char *name, struct termios + *termp, struct winsize *winp) { + int fd; + char buf[20]; +#if 0 + This is what glibc does: + open("/dev/ptmx", O_RDWR) = 4 + statfs("/dev/pts", {f_type=0x1cd1, f_bsize=1024, f_blocks=0, f_bfree=0, f_files=0, f_ffree=0, f_namelen=255}) = 0 + ioctl(4, TCGETS, {B38400 opost isig icanon echo ...}) = 0 + ioctl(4, 0x80045430, [0]) = 0 + stat("/dev/pts/0", {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0 + statfs("/dev/pts/0", {f_type=0x1cd1, f_bsize=1024, f_blocks=0, f_bfree=0, f_files=0, f_ffree=0, f_namelen=255}) = 0 + ioctl(4, 0x40045431, [0]) = 0 + ioctl(4, TCGETS, {B38400 opost isig icanon echo ...}) = 0 + ioctl(4, 0x80045430, [0]) = 0 + stat("/dev/pts/0", {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0 + open("/dev/pts/0", O_RDWR|O_NOCTTY) = 5 +#endif + if ((fd=open("/dev/ptmx",O_RDWR))<0) return -1; +#if 0 + if (ioctl(fd,TCGETS,&ts)<0) goto kaputt; +#endif + { + int unlock=0; + while (ioctl(fd,TIOCSPTLCK, &unlock)<0) if (errno!=EINTR) goto kaputt; + } + { + int ptyno; + while (ioctl(fd,TIOCGPTN,&ptyno)<0) if (errno!=EINTR) goto kaputt; + strcpy(buf,"/dev/pts/"); + __ltostr(buf+9,10,ptyno,10,0); + } + *aslave=open(buf,O_RDWR|O_NOCTTY); + if (*aslave<0) goto kaputt; + *amaster=fd; + if (name) strcpy(name,buf); + if (termp) + while (tcsetattr(*aslave,TCSAFLUSH,termp) && errno==EINTR); + if (winp) while (ioctl(*aslave, TIOCSWINSZ, winp) && errno==EINTR); + return 0; +kaputt: + close(fd); + return -1; +} diff --git a/mdk-stage1/dietlibc/libugly/popen.c b/mdk-stage1/dietlibc/libugly/popen.c index e0e441495..aa9a2cde0 100644 --- a/mdk-stage1/dietlibc/libugly/popen.c +++ b/mdk-stage1/dietlibc/libugly/popen.c @@ -1,32 +1,38 @@ #include "dietstdio.h" #include <unistd.h> +#include <fcntl.h> +#include "binshstr.h" extern char **environ; FILE *popen(const char *command, const char *type) { int pfd[2]; int fd0; + FILE* f; pid_t pid; + if (pipe(pfd)<0) return 0; fd0=(*type=='r'); - if ((pid=vfork())<0) { + if (!(f=fdopen(pfd[!fd0],type))) { + close(pfd[0]); /* malloc failed */ + close(pfd[1]); + return 0; + } + if ((pid=fork())<0) { close(pfd[0]); close(pfd[1]); return 0; } if (!pid) { /* child */ - char *argv[]={"sh","-c",0,0}; + const char *argv[]={__sh,"-c",0,0}; close(pfd[!fd0]); close(fd0); dup2(pfd[fd0],fd0); close(pfd[fd0]); - argv[2]=(char*)command; - execve("/bin/sh",argv,environ); - _exit(255); + argv[2]=command; + execve(__binsh,(char*const*)argv,environ); + _exit(127); } close(pfd[fd0]); - { - register FILE* f; - if ((f=fdopen(pfd[!fd0],type))) - f->popen_kludge=pid; - return f; - } + fcntl (pfd[!fd0], F_SETFD, FD_CLOEXEC); + f->popen_kludge=pid; + return f; } diff --git a/mdk-stage1/dietlibc/libugly/protoent_buf.c b/mdk-stage1/dietlibc/libugly/protoent_buf.c new file mode 100644 index 000000000..0e303a5d4 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/protoent_buf.c @@ -0,0 +1,5 @@ +#include <netdb.h> + +struct protoent __protoent_pw; +char __protoent_buf[1000]; + diff --git a/mdk-stage1/dietlibc/libugly/ptsname.c b/mdk-stage1/dietlibc/libugly/ptsname.c new file mode 100644 index 000000000..a332faf6c --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/ptsname.c @@ -0,0 +1,17 @@ +#define _XOPEN_SOURCE +#include <unistd.h> +#include <sys/ioctl.h> +#include <stdlib.h> +#include <string.h> + +# define MAX_FDS 4 + +char *ptsname(int fd) { + static char buffer[9+MAX_FDS]; /* Ahh..great */ + int pty; + + strcpy(buffer,"/dev/pts/"); + if ((ioctl(fd, TIOCGPTN, &pty)) == -1) return 0; + __ltostr(buffer+9, MAX_FDS, pty, 10, 0); + return buffer; +} diff --git a/mdk-stage1/dietlibc/libugly/putpwent.c b/mdk-stage1/dietlibc/libugly/putpwent.c new file mode 100644 index 000000000..f192c5934 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/putpwent.c @@ -0,0 +1,19 @@ +/* man, what a crook! */ + +#include <pwd.h> +#include <stdio.h> +#include <sys/types.h> +#include <errno.h> +#include "dietwarning.h" + +int putpwent(const struct passwd *p, FILE *stream) { + if (p && stream) { + fprintf(stream,"%s:%s:%d:%d:%s:%s:%s\n", p->pw_name, p->pw_passwd, + p->pw_uid, p->pw_gid, p->pw_gecos, p->pw_dir, p->pw_shell); + return 0; + } + (*__errno_location())=EINVAL; + return -1; +} + +link_warning("putpwent","putpwent is garbage, don't use!") diff --git a/mdk-stage1/dietlibc/libugly/servent_buf.c b/mdk-stage1/dietlibc/libugly/servent_buf.c new file mode 100644 index 000000000..b9e992adf --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/servent_buf.c @@ -0,0 +1,5 @@ +#include <netdb.h> + +struct servent __servent_pw; +char __servent_buf[1000]; + diff --git a/mdk-stage1/dietlibc/libugly/setenv.c b/mdk-stage1/dietlibc/libugly/setenv.c index bf47cdb79..c65910471 100644 --- a/mdk-stage1/dietlibc/libugly/setenv.c +++ b/mdk-stage1/dietlibc/libugly/setenv.c @@ -5,13 +5,15 @@ link_warning("setenv","setenv calls malloc. Avoid it in small programs."); int setenv(const char *name, const char *value, int overwrite) { - char *c=malloc(strlen(name)+strlen(value)+3); if (getenv(name)) { if (!overwrite) return 0; unsetenv(name); } - strcpy(c,name); - strcat(c,"="); - strcat(c,value); - return putenv(c); + { + char *c=malloc(strlen(name)+strlen(value)+3); + strcpy(c,name); + strcat(c,"="); + strcat(c,value); + return putenv(c); + } } diff --git a/mdk-stage1/dietlibc/libugly/strftime.c b/mdk-stage1/dietlibc/libugly/strftime.c index b7e750ab1..365d0c84f 100644 --- a/mdk-stage1/dietlibc/libugly/strftime.c +++ b/mdk-stage1/dietlibc/libugly/strftime.c @@ -1,182 +1,118 @@ #include <sys/types.h> #include <time.h> - -static char *sweekdays[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"}; -static char *weekdays[]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}; -static char *smonths[]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"}; -static char *months[]={"January","February","March","April","May","June","July","August","September","October","November","December"}; -static char *ampm[]={"am","pm","AM","PM"}; - -static int i2a(char* dest,unsigned int x) { - register unsigned int tmp=x; - register int len=0; - *dest++=tmp/10+'0'; tmp=tmp%10; ++len; - *dest++=tmp+'0'; - return 2; +#include "dietfeatures.h" + +static const char sweekdays [7] [4] = { + "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" +}; +static const char weekdays [7] [10] = { + "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" +}; +static const char smonths [12] [4] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" +}; +static const char* months [12] = { + "January", "February", "March", "April", smonths[5-1], "June", + "July", "August", "September", "October", "November", "December" +}; +static const char ampm [4] [3] = { + "am", "pm", + "AM", "PM" +}; + +static int i2a ( char* dest,unsigned int x ) +{ + int div = 10; + *dest++ = x/div + '0'; + *dest++ = x%div + '0'; + *dest++ = '\0'; + return 2; } -static int i2as(char* dest,unsigned int x) { - int len=i2a(dest,x); - if (*dest=='0') *dest=' '; - return len; -} - -size_t strftime(char *s, size_t max, const char *format, const struct tm *tm) { - char *t=s; - const char *src; - char buf[5]; - while (*format) { - switch (*format) { - case 0: break; - case '%': - switch (*++format) { - case '%': *t='%'; ++t; break; - case 'a': src=sweekdays[tm->tm_wday]; goto append; - case 'A': src=weekdays[tm->tm_wday]; goto append; - case 'h': - case 'b': src=smonths[tm->tm_mon]; goto append; - case 'B': src=months[tm->tm_mon]; goto append; - case 'c': t+=strftime(t,max-(t-s),"%b %a %d %k:%M:%S %Z %Y",tm); break; - case 'C': buf[i2a(buf,(tm->tm_year+1900)/100)]=0; src=buf; goto append; - case 'd': buf[i2a(buf,tm->tm_mday)]=0; src=buf; goto append; - case 'e': buf[i2as(buf,tm->tm_mday)]=0; src=buf; goto append; - case 'H': buf[i2a(buf,tm->tm_hour)]=0; src=buf; goto append; - case 'I': buf[i2a(buf,tm->tm_hour%12)]=0; src=buf; goto append; - case 'j': buf[i2a(buf,tm->tm_yday)]=0; src=buf; goto append; - case 'k': buf[i2as(buf,tm->tm_hour)]=0; src=buf; goto append; - case 'l': buf[i2as(buf,tm->tm_hour%12)]=0; src=buf; goto append; - case 'm': buf[i2a(buf,tm->tm_mon+1)]=0; src=buf; goto append; - case 'M': buf[i2a(buf,tm->tm_min)]=0; src=buf; goto append; - case 'n': *t='\n'; break; - case 'p': src=ampm[tm->tm_hour>11?3:2]; goto append; - case 'P': src=ampm[tm->tm_hour>11?1:0]; goto append; - case 'r': t+=strftime(t,max-(t-s),"%I:%M:%S %p",tm); break; - case 'R': t+=strftime(t,max-(t-s),"%H:%M",tm); break; - case 'S': buf[i2a(buf,tm->tm_sec)]=0; src=buf; goto append; - case 't': *t='\t'; break; - case 'T': t+=strftime(t,max-(t-s),"%H:%M:%S",tm); break; - case 'u': buf[i2a(buf,tm->tm_wday?tm->tm_wday:7)]=0; src=buf; goto append; - case 'w': buf[i2a(buf,tm->tm_wday)]=0; src=buf; goto append; - case 'x': t+=strftime(t,max-(t-s),"%b %a %d",tm); break; - case 'X': t+=strftime(t,max-(t-s),"%k:%M:%S",tm); break; - case 'y': buf[i2a(buf,tm->tm_year%100)]=0; src=buf; goto append; - case 'Y': i2a(buf,(tm->tm_year+1900)/100); buf[i2a(buf+2,(tm->tm_year%100))+2]=0; src=buf; goto append; - case 'Z': src="GMT"; goto append; /* hehe */ -append: - while (*src && t<s+max) { *t=*src; ++t; ++src; } - }; - break; - default: - *t=*format; ++t; +size_t strftime ( char* dst, size_t max, const char* format, const struct tm* tm ) +{ + char* p = dst; + const char* src; + unsigned int no; + char buf [5]; + + + for ( ; *format != '\0'; format++ ) { + if (*format == '%') { + if (*++format == '%') { + *p++ = '%'; + } + else +again: + switch (*format) { +// case '%': *p++ = '%'; break; // reduce size of jump table + case 'n': *p++ = '\n'; break; + case 't': *p++ = '\t'; break; + case 'O': case 'E': ++format; goto again; + case 'c': src = "%b %a %d %k:%M:%S %Z %Y"; goto _strf; + case 'r': src = "%I:%M:%S %p"; goto _strf; + case 'R': src = "%H:%M"; goto _strf; + case 'x': src = "%b %a %d"; goto _strf; + case 'X': src = "%k:%M:%S"; goto _strf; + case 'D': src = "%m/%d/%y"; goto _strf; + case 'T': src = "%H:%M:%S"; + _strf: p += strftime (p, (size_t)(dst+max-p), src, tm); break; + case 'a': src = sweekdays [tm->tm_wday]; goto _str; + case 'A': src = weekdays [tm->tm_wday]; goto _str; + case 'h': + case 'b': src = smonths [tm->tm_mon]; goto _str; + case 'B': src = months [tm->tm_mon]; goto _str; + case 'p': src = ampm [tm->tm_hour > 12 ? 3 : 2]; goto _str; + case 'P': src = ampm [tm->tm_hour > 12 ? 1 : 0]; goto _str; + case 'C': no = tm->tm_year/100 + 19; goto _no; + case 'd': no = tm->tm_mday; goto _no; + case 'e': no = tm->tm_mday; goto _nos; + case 'H': no = tm->tm_hour; goto _no; + case 'I': no = tm->tm_hour % 12; goto _no; + case 'j': no = tm->tm_yday; goto _no; + case 'k': no = tm->tm_hour; goto _nos; + case 'l': no = tm->tm_hour % 12; goto _nos; + case 'm': no = tm->tm_mon + 1; goto _no; + case 'M': no = tm->tm_min; goto _no; + case 'S': no = tm->tm_sec; goto _no; + case 'u': no = tm->tm_wday ? tm->tm_wday : 7; goto _no; + case 'w': no = tm->tm_wday; goto _no; + case 'U': no = (tm->tm_yday - tm->tm_wday + 7) / 7; goto _no; + case 'W': no = (tm->tm_yday - (tm->tm_wday - 1 + 7) % 7 + 7) / 7; goto _no; + case 'Z': +#ifdef WANT_TZFILE_PARSER + tzset(); src = tzname[0]; +#else + src = "[unknown timezone]"; +#endif + goto _str; + case 'Y': i2a ( buf+0, (unsigned int)(tm->tm_year / 100 + 19) ); + i2a ( buf+2, (unsigned int)(tm->tm_year % 100) ); + src = buf; + goto _str; + case 'y': no = tm->tm_year % 100; goto _no; + _no: i2a ( buf, no ); /* append number 'no' */ + src = buf; + goto _str; + _nos: i2a ( buf, no ); /* the same, but '0'->' ' */ + if (buf[0] == '0') + buf[0] = ' '; + src = buf; + _str: while (*src && p < dst+max) /* append string */ + *p++ = *src++; + break; + }; + } else { + *p++ = *format; + } + + if (p >= dst+max) + break; } - ++format; - if (t>=s+max) break; - continue; - } - *t=0; return t-s; + + *p = '\0'; + return p - dst; } - -/* - %u The day of the week as a decimal, range 1 to 7, - Monday being 1. See also %w. (SU) - - %U The week number of the current year as a decimal - number, range 00 to 53, starting with the first - Sunday as the first day of week 01. See also %V and - %W. - - %V The ISO 8601:1988 week number of the current year - as a decimal number, range 01 to 53, where week 1 - is the first week that has at least 4 days in the - current year, and with Monday as the first day of - the week. See also %U and %W. (SU) - - %w The day of the week as a decimal, range 0 to 6, - Sunday being 0. See also %u. - - %W The week number of the current year as a decimal - number, range 00 to 53, starting with the first - Monday as the first day of week 01. - - %x The preferred date representation for the current - locale without the time. - - %X The preferred time representation for the current - locale without the date. - - %y The year as a decimal number without a century - (range 00 to 99). - - %Y The year as a decimal number including the century. - - %z The time-zone as hour offset from GMT. Required to - emit RFC822-conformant dates (using "%a, %d %b %Y - %H:%M:%S %z"). (GNU) - - %Z The time zone or name or abbreviation. - - %+ The date and time in date(1) format. (TZ) - - %% A literal `%' character. - - Some conversion specifiers can be modified by preceding - them by the E or O modifier to indicate that an alterna - tive format should be used. If the alternative format or - specification does not exist for the current locale, the - behaviour will be as if the unmodified conversion specifi - cation were used. (SU) The Single Unix Specification men - tions %Ec, %EC, %Ex, %EX, %Ry, %EY, %Od, %Oe, %OH, %OI, - %Om, %OM, %OS, %Ou, %OU, %OV, %Ow, %OW, %Oy, where the - effect of the O modifier is to use alternative numeric - symbols (say, roman numerals), and that of the E modifier - - - -GNU 29 March 1999 3 - - - - - -STRFTIME(3) Linux Programmer's Manual STRFTIME(3) - - - is to use a locale-dependent alternative representation. - - The broken-down time structure tm is defined in <time.h>. - See also ctime(3). - - -RETURN VALUE - The strftime() function returns the number of characters - placed in the array s, not including the terminating NUL - character, provided the string, including the terminating - NUL, fits. Otherwise, it returns 0, and the contents of - the array is undefined. (Thus at least since libc 4.4.4; - very old versions of libc, such as libc 4.4.1, would - return max if the array was too small.) - - Note that the return value 0 does not necessarily indicate - an error; for example, in many locales %p yields an empty - string. - -ENVIRONMENT - The environment variables TZ and LC_TIME are used. - -CONFORMING TO - ANSI C, SVID 3, ISO 9899. There are strict inclusions - between the set of conversions given in ANSI C (unmarked), - those given in the Single Unix Specification (marked SU), - those given in Olson's timezone package (marked TZ), and - those given in glibc (marked GNU), except that %+ is not - supported in glibc2. On the other hand glibc2 has several - more extensions. POSIX.1 only refers to ANSI C; POSIX.2 - describes under date(1) several extensions that could - apply to strftime as well. - -SEE ALSO - date(1), time(2), ctime(3), setlocale(3), sprintf(3) - -*/ diff --git a/mdk-stage1/dietlibc/libugly/strndup.c b/mdk-stage1/dietlibc/libugly/strndup.c new file mode 100644 index 000000000..7f912d4c6 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/strndup.c @@ -0,0 +1,10 @@ +#include <string.h> +#include <stdlib.h> + +char *strndup(const char *s,size_t n) { + char *tmp=(char *)malloc(n+1); + if (!tmp) return 0; + strncpy(tmp,s,n); + tmp[n]=0; + return tmp; +} diff --git a/mdk-stage1/dietlibc/libugly/strsignal.c b/mdk-stage1/dietlibc/libugly/strsignal.c index 54314d2c7..d72777571 100644 --- a/mdk-stage1/dietlibc/libugly/strsignal.c +++ b/mdk-stage1/dietlibc/libugly/strsignal.c @@ -1,92 +1,10 @@ +#define _GNU_SOURCE +#include <string.h> #include <signal.h> -/* F....ng Kernel haeder is damn broken... */ -#ifndef _NSIG -#define _NSIG 64 -#endif -#include <asm/signal.h> -char * strsignal(int sig) { - if (sig==SIGHUP) - return "Hangup"; - else if (sig==SIGINT) - return "Interrupt"; - else if (sig==SIGQUIT) - return "Quit"; - else if (sig==SIGILL) - return "Illegal instruction"; - else if (sig==SIGTRAP) - return "Trace/breakpoint trap"; - else if (sig==SIGABRT) - return "Aborted"; - else if (sig==SIGFPE) - return "Floating point exception"; - else if (sig==SIGKILL) - return "Killed"; - else if (sig==SIGBUS) - return "Bus error"; - else if (sig==SIGSEGV) - return "Segmentation fault"; - else if (sig==SIGPIPE) - return "Broken pipe"; - else if (sig==SIGALRM) - return "Alarm clock"; - else if (sig==SIGTERM) - return "Terminated"; - else if (sig==SIGURG) - return "Urgent I/O condition"; - else if (sig==SIGSTOP) - return "Stopped (signal)"; - else if (sig==SIGTSTP) - return "Stopped"; - else if (sig==SIGCONT) - return "Continue"; - else if (sig==SIGCHLD) - return "Child exited"; - else if (sig==SIGTTIN) - return "Stopped (tty input)"; - else if (sig==SIGTTOU) - return "Stopped (tty output)"; - else if (sig==SIGIO) - return "I/O possible"; - else if (sig==SIGXCPU) - return "CPU time limit exceeded"; - else if (sig==SIGXFSZ) - return "File size limit exceeded"; - else if (sig==SIGVTALRM) - return "Virtual timer expired"; - else if (sig==SIGPROF) - return "Profiling timer expired"; - else if (sig==SIGWINCH) - return "Window changed"; - else if (sig==SIGUSR1) - return "User defined signal 1"; - else if (sig==SIGUSR2) - return "User defined signal 1"; -#ifdef SIGEMT - else if (sig==SIGEMT) - return "EMT trap"; -#endif -#ifdef SIGSYS - else if (sig==SIGSYS) - return "Bad system call"; -#endif -#ifdef SIGSTKFLT - else if (sig==SIGSTKFLT) - return "Stack fault"; -#endif -#ifdef SIGINFO - else if (sig==SIGINFO) - return "Information request"; -#elif defined(SIGPWR) && (!defined(SIGLOST) || (SIGPWR!=SIGLOST)) - else if (sig==SIGPWR) - return "Power falure"; -#endif -#ifdef SIGLOST - else if (sig==SIGLOST) - return "Resource lost"; -#endif - else if ((sig>=SIGRTMIN)&&(sig<=SIGRTMAX)) - return "Real time signal"; +const char* strsignal(int sig) { + if (sig<=SIGRTMAX) + return sys_siglist[sig]; else return "(unknown signal)"; } diff --git a/mdk-stage1/dietlibc/libugly/system.c b/mdk-stage1/dietlibc/libugly/system.c index b9eea20eb..714aad056 100644 --- a/mdk-stage1/dietlibc/libugly/system.c +++ b/mdk-stage1/dietlibc/libugly/system.c @@ -1,23 +1,19 @@ #include <signal.h> -#include <asm/errno.h> #include <errno.h> #include <unistd.h> +#include <sys/wait.h> #include "dietwarning.h" - -#define SHELL_PATH "/bin/sh" /* Path of the shell. */ -#define SHELL_NAME "sh" /* Name to give it. */ +#include "dietfeatures.h" +#include "binshstr.h" extern char **environ; -int __libc_fork(); -int __libc_waitpid(int pid, int *status, int options); -int execve(const char*filename, char *const argv[], char *const envp[]); -void __set_errno(int errno); -int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); +int __libc_system (const char *line); int __libc_system (const char *line) { struct sigaction sa, intr, quit; + sigset_t block,omask; int save,pid,ret=-1; if (line == 0) return __libc_system("exit 0") == 0; @@ -29,38 +25,48 @@ int __libc_system (const char *line) if (sigaction(SIGINT, &sa, &intr)<0) return -1; if (sigaction(SIGQUIT, &sa, &quit)<0) { save = errno; +undo: sigaction (SIGINT, &intr, (struct sigaction*)0); - __set_errno (save); + errno=save; return -1; } + sigemptyset(&block); + sigaddset(&block,SIGCHLD); + if (sigprocmask(SIG_BLOCK,&block,&omask)<0) { + save=errno; + sigaction (SIGQUIT, &quit, (struct sigaction*)0); + goto undo; + } - pid=__libc_fork(); + pid=fork(); if (pid>0) { /* parent */ int n; do - n=__libc_waitpid(pid, &ret, 0); + n=waitpid(pid, &ret, 0); while ((n==-1) && (errno==EINTR)); if (n!=pid) ret=-1; } else if (!pid) { /* child */ const char *nargs[4]; - nargs[0] = SHELL_NAME; + nargs[0] = __sh; nargs[1] = "-c"; nargs[2] = line; nargs[3] = 0; sigaction(SIGINT, &intr, (struct sigaction*)0); sigaction(SIGQUIT, &quit, (struct sigaction*)0); + sigprocmask(SIG_SETMASK,&omask,0); - execve(SHELL_PATH,(char *const *)nargs, environ); + execve(__binsh,(char *const *)nargs, environ); _exit(127); } save = errno; sigaction (SIGINT, &intr, (struct sigaction *)0); sigaction (SIGQUIT, &quit, (struct sigaction *)0); - __set_errno(save); + sigprocmask(SIG_SETMASK,&omask,0); + errno=save; return ret; } diff --git a/mdk-stage1/dietlibc/libugly/time_table_spd.c b/mdk-stage1/dietlibc/libugly/time_table_spd.c index bfe1cf86d..6850d76c4 100644 --- a/mdk-stage1/dietlibc/libugly/time_table_spd.c +++ b/mdk-stage1/dietlibc/libugly/time_table_spd.c @@ -1,6 +1,7 @@ +#include <time.h> -/* seconds per month -- nonleap! */ -const unsigned int __spm[12] = +/* days per month -- nonleap! */ +const short __spm[12] = { 0, (31), (31+28), diff --git a/mdk-stage1/dietlibc/libugly/timezone.c b/mdk-stage1/dietlibc/libugly/timezone.c new file mode 100644 index 000000000..e8a94a906 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/timezone.c @@ -0,0 +1,3 @@ + +long int timezone; +int daylight; diff --git a/mdk-stage1/dietlibc/libugly/tzfile.c b/mdk-stage1/dietlibc/libugly/tzfile.c index 5702d4bea..e0e8f7846 100644 --- a/mdk-stage1/dietlibc/libugly/tzfile.c +++ b/mdk-stage1/dietlibc/libugly/tzfile.c @@ -3,28 +3,30 @@ #include <fcntl.h> #include <sys/mman.h> #include <netinet/in.h> +#include <time.h> -#include <stdio.h> +/* #include <stdio.h> */ + +char* tzname[2]={"GMT","GMT"}; #ifdef WANT_TZFILE_PARSER static char *tzfile=0; static int tzlen=-1; -void __maplocaltime() { +void __maplocaltime(void); +void __maplocaltime(void) { int fd; unsigned int len; if (tzlen>=0) return; tzlen=0; if ((fd=open("/etc/localtime",O_RDONLY))<0) return; len=lseek(fd,0,SEEK_END); - if ((tzfile=mmap(0,len,PROT_READ,MAP_SHARED,fd,0))==MAP_FAILED) return; + if ((tzfile=mmap(0,len,PROT_READ,MAP_PRIVATE,fd,0))==MAP_FAILED) return; close(fd); if (ntohl(*(int*)tzfile) != 0x545a6966) return; tzlen=len; } -char *tzset(void) __attribute__((weak,alias("__maplocaltime"))); - static unsigned long __myntohl(const unsigned char* c) { return (((unsigned long)c[0])<<24) + (((unsigned long)c[1])<<16) + @@ -32,6 +34,7 @@ static unsigned long __myntohl(const unsigned char* c) { ((unsigned long)c[3]); } +time_t __tzfile_map(time_t t, int *isdst); time_t __tzfile_map(time_t t, int *isdst) { /* "TZif" plus 16 reserved bytes. */ char *tmp; @@ -64,23 +67,41 @@ time_t __tzfile_map(time_t t, int *isdst) { printf("%s(%lu,%d,%d)",i?", ":"",ntohl(*(int*)tmp),tmp[4],tmp[5]); tmp+=6; } printf("\n"); + for (i=0; i<tzh_charcnt; ++i) { + printf("%s\"%s\"",i?", ":"",tmp); + tmp+=strlen(tmp); + } + printf("\n"); #endif tmp=tzfile+20+6*4; - for (i=0; i<tzh_timecnt; ++i) + daylight=(tzh_timecnt>0); + for (i=0; i<tzh_timecnt; ++i) { if ((time_t)__myntohl(tmp+i*4) >= t) { + char* tz=tmp; /* printf("match at %d\n",i); */ tmp+=tzh_timecnt*4; i=tmp[i-1]; /* printf("using index %d\n",i); */ tmp+=tzh_timecnt; + tz+=tzh_timecnt*5+tzh_leapcnt*4+tzh_typecnt*6; tmp+=i*6; /* printf("(%lu,%d,%d)\n",ntohl(*(int*)tmp),tmp[4],tmp[5]); */ *isdst=tmp[4]; - return t+__myntohl(tmp); + tzname[0]=tz+tmp[5]; + timezone=-(__myntohl(tmp)); + return t-timezone; } + } return t; } + +void tzset(void) { + int isdst; + __maplocaltime(); + __tzfile_map(time(0),&isdst); +} + #else -void tzset(void) __attribute__((weak,alias("return0"))); +void tzset(void) __attribute__((weak,alias("__nop"))); #endif diff --git a/mdk-stage1/dietlibc/libugly/unlockpt.c b/mdk-stage1/dietlibc/libugly/unlockpt.c new file mode 100644 index 000000000..e0246ed8e --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/unlockpt.c @@ -0,0 +1,10 @@ +#define _XOPEN_SOURCE +#include <sys/ioctl.h> +#include <unistd.h> +#include <stdlib.h> + +int unlockpt (int fd) { + int foo; + /* hehe, that one is easy */ + return (ioctl (fd, TIOCSPTLCK, &foo)); +} diff --git a/mdk-stage1/dietlibc/libugly/utent.c b/mdk-stage1/dietlibc/libugly/utent.c new file mode 100644 index 000000000..d8d5d1ba7 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/utent.c @@ -0,0 +1,103 @@ +#include <unistd.h> +#include <fcntl.h> +#include <string.h> +#include <utmp.h> + +static const char *utmp_file_name = _PATH_UTMP; +static int fd = -1; + +static int lock_record(int type) { + struct flock fl; + fl.l_whence = SEEK_CUR; + fl.l_start = 0; + fl.l_len = sizeof(struct utmp); + fl.l_pid = 0; + fl.l_type = type; + return fcntl(fd, F_SETLKW, &fl); +} + +static int unlock_record() { + struct flock fl; + fl.l_whence = SEEK_CUR; + fl.l_start = -sizeof(struct utmp); + fl.l_len = sizeof(struct utmp); + fl.l_pid = 0; + fl.l_type = F_UNLCK; + return fcntl(fd, F_SETLK, &fl); +} + +void utmpname(const char *file) { + if (file) + utmp_file_name = file; + else + utmp_file_name = _PATH_UTMP; +} + +void setutent() { + if (fd<0) fd = open(utmp_file_name,O_RDWR); + if (fd<0) fd = open(utmp_file_name,O_RDONLY); + fcntl (fd, F_SETFD, FD_CLOEXEC); + lseek(fd,0,SEEK_SET); +} + +void endutent() { + if (fd<0) return; + close(fd); fd=-1; +} + +struct utmp *getutent(void) { + static struct utmp getutent_tmp; + int ret; + + if (fd<0) { + setutent(); + if (fd<0) return 0; + } + if (lock_record(F_RDLCK)) return 0; + ret=read(fd, &getutent_tmp, sizeof(struct utmp)); + unlock_record(); + if (ret<1) return 0; + return &getutent_tmp; +} + +struct utmp *getutid(struct utmp *ut) { + struct utmp *tmp; + + while ((tmp = getutent())) { + if (ut->ut_type && (ut->ut_type <= OLD_TIME)) { + if (ut->ut_type == tmp->ut_type) break; + } + if ((ut->ut_type >= INIT_PROCESS) && (ut->ut_type <= DEAD_PROCESS)) { + if (!strncmp(ut->ut_id,tmp->ut_id,4)) break; + } + } + return tmp; +} + +struct utmp *getutline(struct utmp *ut) { + struct utmp *tmp; + + while ((tmp = getutent())) { + if ((tmp->ut_type == USER_PROCESS) || (tmp->ut_type == LOGIN_PROCESS)) { + if (!strncmp(ut->ut_line,tmp->ut_line,UT_LINESIZE)) break; + } + } + return tmp; +} + +void pututline(struct utmp *ut) { + struct utmp *tmp; + + if ((tmp = getutid(ut))) { + lseek(fd, - (off_t)sizeof(struct utmp), SEEK_CUR); + if (lock_record(F_WRLCK)) return; + write(fd, ut, sizeof(struct utmp)); + } + else { + lseek(fd, 0, SEEK_END); + if (lock_record(F_WRLCK)) return; + write(fd, ut, (off_t)sizeof(struct utmp)); + } + unlock_record(); +} + diff --git a/mdk-stage1/dietlibc/libugly/wtent.c b/mdk-stage1/dietlibc/libugly/wtent.c new file mode 100644 index 000000000..1ca7c3202 --- /dev/null +++ b/mdk-stage1/dietlibc/libugly/wtent.c @@ -0,0 +1,30 @@ +#include <unistd.h> +#include <fcntl.h> +#include <string.h> +#include <utmp.h> + +void updwtmp(const char *wtmp_file, const struct utmp *ut) { + int fd = open(wtmp_file, O_WRONLY|O_APPEND); + if (fd<0) return; + fcntl (fd, F_SETFD, FD_CLOEXEC); + write(fd, ut, sizeof(struct utmp)); + close(fd); +} + +void logwtmp(const char *line, const char *name, const char *host) { + struct utmp ut; + + memset(&ut, 0, sizeof(struct utmp)); + + ut.ut_pid = getpid (); + ut.ut_type = name[0] ? USER_PROCESS : DEAD_PROCESS; + + memccpy (ut.ut_line, line, 0, sizeof ut.ut_line); + memccpy (ut.ut_name, name, 0, sizeof ut.ut_name); + memccpy (ut.ut_host, host, 0, sizeof ut.ut_host); + + gettimeofday (&ut.ut_tv, NULL); + + updwtmp (_PATH_WTMP, &ut); +} + |