From ff96d53e3f12a970f3052896203191d118344c4d Mon Sep 17 00:00:00 2001 From: leitner Date: Mon, 16 Sep 2002 23:49:15 +0000 Subject: [PATCH] even more man pages --- case.h | 3 +-- case/case_diffb.3 | 12 ++++++++++ case/case_diffs.3 | 12 ++++++++++ case/case_lowerb.3 | 12 ++++++++++ case/case_lowers.3 | 12 ++++++++++ case/case_starts.3 | 12 ++++++++++ case/case_starts.c | 19 +++++++++++++++ open/openreadclose.3 | 16 +++++++++++++ open/readclose.3 | 14 +++++++++++ open/readclose_append.3 | 16 +++++++++++++ t.c | 35 ++++------------------------ tai.h | 34 +++++++++++++++++++++++++++ tai/tai_add.3 | 13 +++++++++++ tai/tai_approx.3 | 12 ++++++++++ tai/tai_less.3 | 12 ++++++++++ tai/tai_now.3 | 18 +++++++++++++++ tai/tai_pack.3 | 14 +++++++++++ tai/tai_sub.3 | 13 +++++++++++ tai/tai_unpack.3 | 12 ++++++++++ taia/taia_add.3 | 13 +++++++++++ taia/taia_addsec.3 | 13 +++++++++++ taia/taia_approx.3 | 12 ++++++++++ taia/taia_frac.3 | 12 ++++++++++ taia/taia_less.3 | 12 ++++++++++ taia/taia_now.3 | 22 ++++++++++++++++++ taia/taia_pack.3 | 14 +++++++++++ taia/taia_sub.3 | 13 +++++++++++ taia/taia_tai.3 | 11 +++++++++ taia/taia_uint.3 | 10 ++++++++ taia/taia_unpack.3 | 12 ++++++++++ taia/taia_unpack.c | 22 ++++++++++++++++++ test/dnsip.c | 39 +++++++++++++++++++++++++++++++ unix/iopause.3 | 51 +++++++++++++++++++++++++++++++++++++++++ 33 files changed, 514 insertions(+), 33 deletions(-) create mode 100644 case/case_diffb.3 create mode 100644 case/case_diffs.3 create mode 100644 case/case_lowerb.3 create mode 100644 case/case_lowers.3 create mode 100644 case/case_starts.3 create mode 100644 case/case_starts.c create mode 100644 open/openreadclose.3 create mode 100644 open/readclose.3 create mode 100644 open/readclose_append.3 create mode 100644 tai/tai_add.3 create mode 100644 tai/tai_approx.3 create mode 100644 tai/tai_less.3 create mode 100644 tai/tai_now.3 create mode 100644 tai/tai_pack.3 create mode 100644 tai/tai_sub.3 create mode 100644 tai/tai_unpack.3 create mode 100644 taia/taia_add.3 create mode 100644 taia/taia_addsec.3 create mode 100644 taia/taia_approx.3 create mode 100644 taia/taia_frac.3 create mode 100644 taia/taia_less.3 create mode 100644 taia/taia_now.3 create mode 100644 taia/taia_pack.3 create mode 100644 taia/taia_sub.3 create mode 100644 taia/taia_tai.3 create mode 100644 taia/taia_uint.3 create mode 100644 taia/taia_unpack.3 create mode 100644 taia/taia_unpack.c create mode 100644 test/dnsip.c create mode 100644 unix/iopause.3 diff --git a/case.h b/case.h index 27049b0..c7e60bf 100644 --- a/case.h +++ b/case.h @@ -13,9 +13,8 @@ extern int case_diffb(const char *,unsigned int,const char *); /* like str_start, ignoring case */ extern int case_starts(const char *,const char *); -/* alias for case_diffb? */ -extern int case_startb(const char *,unsigned int,const char *); #define case_equals(s,t) (!case_diffs((s),(t))) +#define case_equalb(s,n,t) (!case_diffb((s),(n),(t))) #endif diff --git a/case/case_diffb.3 b/case/case_diffb.3 new file mode 100644 index 0000000..48713c2 --- /dev/null +++ b/case/case_diffb.3 @@ -0,0 +1,12 @@ +.TH case_diffb 3 +.SH NAME +case_diffb \- compare strings case-insensitively +.SH SYNTAX +.B #include + +int \fBcase_diffb\fP(const char* \fIa\fR,const char* \fIb\fR); +.SH DESCRIPTION +case_diffb is similar to byte_diff. The difference is that for the +comparison 'A' == 'a', 'B' == 'b', ..., 'Z' == 'z'. +.SH "SEE ALSO" +byte_diff(3) diff --git a/case/case_diffs.3 b/case/case_diffs.3 new file mode 100644 index 0000000..720f458 --- /dev/null +++ b/case/case_diffs.3 @@ -0,0 +1,12 @@ +.TH case_diffs 3 +.SH NAME +case_diffs \- compare strings case-insensitively +.SH SYNTAX +.B #include + +int \fBcase_diffs\fP(const char* \fIa\fR,const char* \fIb\fR); +.SH DESCRIPTION +case_diffs is similar to str_diff. The difference is that for the +comparison 'A' == 'a', 'B' == 'b', ..., 'Z' == 'z'. +.SH "SEE ALSO" +str_diff(3) diff --git a/case/case_lowerb.3 b/case/case_lowerb.3 new file mode 100644 index 0000000..09e1619 --- /dev/null +++ b/case/case_lowerb.3 @@ -0,0 +1,12 @@ +.TH case_lowerb 3 +.SH NAME +case_lowerb \- compare strings case-insensitively +.SH SYNTAX +.B #include + +int \fBcase_lowerb\fP(char* \fIs\fR,unsigned int \fIlen\fR); +.SH DESCRIPTION +case_lowerb converts each 'A' to 'a', 'B' to 'b', ..., 'Z' to 'z' in +\fIs\fR[0], \fIs\fR[1], ..., \fIs\fR[\fIlen\fR]. +.SH "SEE ALSO" +case_lowerb(3) diff --git a/case/case_lowers.3 b/case/case_lowers.3 new file mode 100644 index 0000000..5c1fe54 --- /dev/null +++ b/case/case_lowers.3 @@ -0,0 +1,12 @@ +.TH case_lowers 3 +.SH NAME +case_lowers \- compare strings case-insensitively +.SH SYNTAX +.B #include + +int \fBcase_lowers\fP(char* \fIs\fR); +.SH DESCRIPTION +case_lowers converts each 'A' to 'a', 'B' to 'b', ..., 'Z' to 'z' for +each character in \fIs\fR until the first \\0. +.SH "SEE ALSO" +case_lowerb(3) diff --git a/case/case_starts.3 b/case/case_starts.3 new file mode 100644 index 0000000..cabd3c9 --- /dev/null +++ b/case/case_starts.3 @@ -0,0 +1,12 @@ +.TH case_starts 3 +.SH NAME +case_starts \- compare prefixes of strings case-insensitively +.SH SYNTAX +.B #include + +int \fBcase_starts\fP(const char* \fIa\fR,const char* \fIb\fR); +.SH DESCRIPTION +case_starts returns 1 if \fIb\fR is a prefix of \fIa\fR, 0 otherwise. +For this comparison, 'A' == 'a', 'B' == 'b', ..., 'Z' == 'z'. +.SH "SEE ALSO" +str_start(3) diff --git a/case/case_starts.c b/case/case_starts.c new file mode 100644 index 0000000..d5eb945 --- /dev/null +++ b/case/case_starts.c @@ -0,0 +1,19 @@ +#include "case.h" + +/* str_start returns 1 if the b is a prefix of a, 0 otherwise */ +int case_starts(const char* a, const char* b) { + register const char* s=a; + register const char* t=b; + for (;;) { + register unsigned char x,y; + if (!*t) return 1; + x = *s - 'A'; + if (x <= 'Z' - 'A') x += 'a'; else x += 'A'; + y = *t - 'A'; + if (y <= 'Z' - 'A') y += 'a'; else y += 'A'; + if (x != y) break; + if (!x) break; + ++s; ++t; + } + return 0; +} diff --git a/open/openreadclose.3 b/open/openreadclose.3 new file mode 100644 index 0000000..eb48992 --- /dev/null +++ b/open/openreadclose.3 @@ -0,0 +1,16 @@ +.TH openreadclose 3 +.SH NAME +openreadclose \- read a whole file into a stralloc +.SH SYNTAX +.B #include + +extern int \fBopenreadclose\fP(const char *\fIfilename\fR, + stralloc* \fIsa\fR,unsigned int \fIbufsize\fR); +.SH DESCRIPTION +openreadclose opens the file \fIfilename\fR for reading and reads the +whole content into the stralloc \fIsa\fR. The file is read in chunks of +\fIbufsize\fR bytes size. If everything worked fine, openreadclose +returns 0. A not existing file is treated as an empty file. On error, +openreadclose returns -1 and sets errno appropriately. +.SH "SEE ALSO" +open_read(3), readclose(3) diff --git a/open/readclose.3 b/open/readclose.3 new file mode 100644 index 0000000..3e3cc14 --- /dev/null +++ b/open/readclose.3 @@ -0,0 +1,14 @@ +.TH readclose 3 +.SH NAME +readclose \- read a whole file into a stralloc +.SH SYNTAX +.B #include + +int \fBreadclose\fP(int fd,stralloc* \fIsa\fR,unsigned int \fIbufsize\fR); +.SH DESCRIPTION +readclose reads the +whole content into the stralloc \fIsa\fR. The file is read in chunks of +\fIbufsize\fR bytes size. If everything worked fine, readclose returns +0. On error, readclose returns -1 and sets errno appropriately. +.SH "SEE ALSO" +open_read(3), openreadclose(3), readclose_append(3) diff --git a/open/readclose_append.3 b/open/readclose_append.3 new file mode 100644 index 0000000..aa46c65 --- /dev/null +++ b/open/readclose_append.3 @@ -0,0 +1,16 @@ +.TH readclose_append 3 +.SH NAME +readclose_append \- read a whole file into a stralloc +.SH SYNTAX +.B #include + +int \fBreadclose_append\fP(int fd,stralloc* \fIsa\fR, + unsigned int \fIbufsize\fR); +.SH DESCRIPTION +readclose_append reads the +whole content into the stralloc \fIsa\fR, appending it to the existing +content. The file is read in chunks of +\fIbufsize\fR bytes size. If everything worked fine, readclose_append returns +0. On error, readclose_append returns -1 and sets errno appropriately. +.SH "SEE ALSO" +open_read(3), openreadclose(3), readclose(3) diff --git a/t.c b/t.c index f5ba1f3..e622281 100644 --- a/t.c +++ b/t.c @@ -22,37 +22,10 @@ __asm__ __volatile__ ("rdtsc" : "=a" (low) : : "edx") int main(int argc,char* argv[]) { - static char seed[128]; - static stralloc fqdn; - static stralloc out; - char str[IP4_FMT]; - int i; - - dns_random_init(seed); - if (*argv) ++argv; - while (*argv) { - if (!stralloc_copys(&fqdn,*argv)) { - buffer_putsflush(buffer_2,"out of memory\n"); - return 111; - } - if (dns_ip4(&out,&fqdn) == -1) { - buffer_puts(buffer_2,"unable to find IP address for "); - buffer_puts(buffer_2,*argv); - buffer_puts(buffer_2,": "); - buffer_puts(buffer_2,strerror(errno)); - buffer_putnlflush(buffer_2); - return 111; - } - - for (i = 0;i + 4 <= out.len;i += 4) { - buffer_put(buffer_1,str,ip4_fmt(str,out.s + i)); - buffer_puts(buffer_1," "); - } - buffer_puts(buffer_1,"\n"); - ++argv; - } - buffer_flush(buffer_1); - return 0; + printf("%d\n",case_starts("fnordhausen","FnOrD")); + printf("%d\n",case_starts("fnordhausen","blah")); + printf("%d\n",case_startb("fnordhausen",5,"FnOrD")); + printf("%d\n",case_startb("fnordhausen",1,"foo")); #if 0 char buf[]="FnOrD"; case_lowers(buf); diff --git a/tai.h b/tai.h index b8db5e5..7c07387 100644 --- a/tai.h +++ b/tai.h @@ -1,24 +1,58 @@ #ifndef TAI_H #define TAI_H +/* Times with 1 second precision */ + #include "uint64.h" +/* A struct tai value is an integer between 0 inclusive and 2^64 + * exclusive. The format of struct tai is designed to speed up common + * operations; applications should not look inside struct tai. + * + * A struct tai variable is commonly used to store a TAI64 label. Each + * TAI64 label refers to one second of real time. TAI64 labels span a + * range of hundreds of billions of years. + * + * A struct tai variable may also be used to store the numerical + * difference between two TAI64 labels. + * See http://cr.yp.to/libtai/tai64.html */ + struct tai { uint64 x; } ; + #define tai_unix(t,u) ((void) ((t)->x = 4611686018427387914ULL + (uint64) (u))) +/* tai_now puts the current time into t. More precisely: tai_now puts + * into t its best guess as to the TAI64 label for the 1-second interval + * that contains the current time. + * + * This implementation of tai_now assumes that the time_t returned from + * the time function represents the number of TAI seconds since + * 1970-01-01 00:00:10 TAI. This matches the convention used by the + * Olson tz library in ``right'' mode. */ extern void tai_now(struct tai *); +/* tai_approx returns a double-precision approximation to t. The result + * of tai_approx is always nonnegative. */ #define tai_approx(t) ((double) ((t)->x)) +/* tai_add adds a to b modulo 2^64 and puts the result into t. The + * inputs and output may overlap. */ extern void tai_add(struct tai *,const struct tai *,const struct tai *); +/* tai_sub subtracts b from a modulo 2^64 and puts the result into t. + * The inputs and output may overlap. */ extern void tai_sub(struct tai *,const struct tai *,const struct tai *); +/* tai_less returns 1 if a is less than b, 0 otherwise. */ #define tai_less(t,u) ((t)->x < (u)->x) #define TAI_PACK 8 +/* tai_pack converts a TAI64 label from internal format in t to external + * TAI64 format in buf. */ extern void tai_pack(char *,const struct tai *); +/* tai_unpack converts a TAI64 label from external TAI64 format in buf + * to internal format in t. */ extern void tai_unpack(const char *,struct tai *); extern void tai_uint(struct tai *,unsigned int); diff --git a/tai/tai_add.3 b/tai/tai_add.3 new file mode 100644 index 0000000..693e67d --- /dev/null +++ b/tai/tai_add.3 @@ -0,0 +1,13 @@ +.TH tai_add 3 +.SH NAME +tai_add \- add two struct tai +.SH SYNTAX +.B #include + +extern int \fBtai_add\fP(struct tai* \fIt\fR,const struct tai* \fIa\fR, + const struct tai* \fIb\fR); +.SH DESCRIPTION +\fBtai_add\fR adds \fIa\fR to \fIb\fR and writes the result to \fIt\fR. +The inputs and output may overlap. +.SH "SEE ALSO" +taia_add(3), tai_sub(3) diff --git a/tai/tai_approx.3 b/tai/tai_approx.3 new file mode 100644 index 0000000..6342e15 --- /dev/null +++ b/tai/tai_approx.3 @@ -0,0 +1,12 @@ +.TH tai_approx 3 +.SH NAME +tai_approx \- return double-precision approximation +.SH SYNTAX +.B #include + +extern int \fBtai_approx\fP(const struct tai* \fIt\fR); +.SH DESCRIPTION +tai_approx returns a double-precision approximation of \fIt\fR. The result of +tai_approx is always nonnegative. +.SH "SEE ALSO" +taia_approx(3) diff --git a/tai/tai_less.3 b/tai/tai_less.3 new file mode 100644 index 0000000..5e8429f --- /dev/null +++ b/tai/tai_less.3 @@ -0,0 +1,12 @@ +.TH tai_less 3 +.SH NAME +tai_less \- compare two struct tai +.SH SYNTAX +.B #include + +extern int \fBtai_less\fP(const struct tai* \fIa\fR, + const struct tai* \fIb\fR); +.SH DESCRIPTION +\fBtai_less\fR returns 1 if \fIa\fR is less than \fIb\fR, 0 otherwise. +.SH "SEE ALSO" +taia_less(3) diff --git a/tai/tai_now.3 b/tai/tai_now.3 new file mode 100644 index 0000000..9e5d72f --- /dev/null +++ b/tai/tai_now.3 @@ -0,0 +1,18 @@ +.TH tai_now 3 +.SH NAME +tai_now \- get current time +.SH SYNTAX +.B #include + +extern int \fBtai_now\fP(struct tai* \fIt\fR); +.SH DESCRIPTION +tai_now puts the current time into \fIt\fR. More precisely: tai_now puts into +\fIt\fR its best guess as to the TAI64 label for the 1-second interval that +contains the current time. + +This implementation of tai_now assumes that the time_t returned from the +time function represents the number of TAI seconds since 1970-01-01 +00:00:10 TAI. This matches the convention used by the Olson tz library +in ``right'' mode. +.SH "SEE ALSO" +taia_now(3) diff --git a/tai/tai_pack.3 b/tai/tai_pack.3 new file mode 100644 index 0000000..7da43b8 --- /dev/null +++ b/tai/tai_pack.3 @@ -0,0 +1,14 @@ +.TH tai_pack 3 +.SH NAME +tai_pack \- convert to external TAI64 format +.SH SYNTAX +.B #include + +extern int \fBtai_pack\fP(char* buf,const struct tai* \fIt\fR); +.SH DESCRIPTION +tai_pack converts a TAI64 label from internal format in \fIt\fR to external +TAI64 format in \fIbuf\fR. + +See http://cr.yp.to/libtai/tai64.html +.SH "SEE ALSO" +taia_pack(3), tai_unpack(3) diff --git a/tai/tai_sub.3 b/tai/tai_sub.3 new file mode 100644 index 0000000..6e333a3 --- /dev/null +++ b/tai/tai_sub.3 @@ -0,0 +1,13 @@ +.TH tai_sub 3 +.SH NAME +tai_sub \- subtract two struct tai +.SH SYNTAX +.B #include + +extern int \fBtai_sub\fP(struct tai* \fIt\fR,const struct tai* \fIa\fR, + const struct tai* \fIb\fR); +.SH DESCRIPTION +\fBtai_sub\fR subtracts \fIb\fR from \fIa\fR and writes the result to \fIt\fR. +The inputs and output may overlap. +.SH "SEE ALSO" +taia_sub(3), tai_add(3) diff --git a/tai/tai_unpack.3 b/tai/tai_unpack.3 new file mode 100644 index 0000000..3691e02 --- /dev/null +++ b/tai/tai_unpack.3 @@ -0,0 +1,12 @@ +.TH tai_unpack 3 +.SH NAME +tai_unpack \- convert to external TAI64 format +.SH SYNTAX +.B #include + +extern int \fBtai_unpack\fP(const char* buf,struct tai* \fIt\fR); +.SH DESCRIPTION +tai_unpack converts a TAI64 label from external TAI64 format in +\fIbuf\fR to internal format in \fIt\fR. +.SH "SEE ALSO" +taia_unpack(3), tai_pack(3) diff --git a/taia/taia_add.3 b/taia/taia_add.3 new file mode 100644 index 0000000..a32701c --- /dev/null +++ b/taia/taia_add.3 @@ -0,0 +1,13 @@ +.TH taia_add 3 +.SH NAME +taia_add \- add two struct taia +.SH SYNTAX +.B #include + +extern int \fBtaia_add\fP(struct taia* \fIt\fR,const struct taia* \fIa\fR, + const struct taia* \fIb\fR); +.SH DESCRIPTION +\fBtaia_add\fR adds \fIa\fR to \fIb\fR and writes the result to \fIt\fR. +The inputs and output may overlap. +.SH "SEE ALSO" +tai_add(3), taia_sub(3), taia_addsec(3) diff --git a/taia/taia_addsec.3 b/taia/taia_addsec.3 new file mode 100644 index 0000000..d0d9226 --- /dev/null +++ b/taia/taia_addsec.3 @@ -0,0 +1,13 @@ +.TH taia_addsec 3 +.SH NAME +taia_addsec \- add n seconds to a struct taia +.SH SYNTAX +.B #include + +extern int \fBtaia_addsec\fP(struct taia* \fIt\fR,const struct taia* \fIs\fR, + int \fIsecs\fR); +.SH DESCRIPTION +\fBtaia_addsec\fR adds \fIsecs\fR seconds to \fIs\fR and writes the result to \fIt\fR. +The inputs and output may overlap. +.SH "SEE ALSO" +taia_sub(3), taia_add(3) diff --git a/taia/taia_approx.3 b/taia/taia_approx.3 new file mode 100644 index 0000000..79d6e07 --- /dev/null +++ b/taia/taia_approx.3 @@ -0,0 +1,12 @@ +.TH taia_approx 3 +.SH NAME +taia_approx \- return double-precision approximation +.SH SYNTAX +.B #include + +extern int \fBtaia_approx\fP(const struct taia* \fIt\fR); +.SH DESCRIPTION +taia_approx returns a double-precision approximation of \fIt\fR. The result of +taia_approx is always nonnegative. +.SH "SEE ALSO" +tai_approx(3) diff --git a/taia/taia_frac.3 b/taia/taia_frac.3 new file mode 100644 index 0000000..0affa17 --- /dev/null +++ b/taia/taia_frac.3 @@ -0,0 +1,12 @@ +.TH taia_frac 3 +.SH NAME +taia_frac \- get current time +.SH SYNTAX +.B #include + +int \fBtaia_frac\fP(const struct taia* \fIt\fR); +.SH DESCRIPTION +taia_frac returns a double-precision approximation to the fraction part +of \fIt\fR. The result of taia_frac is always nonnegative. +.SH "SEE ALSO" +taia_approx(3) diff --git a/taia/taia_less.3 b/taia/taia_less.3 new file mode 100644 index 0000000..b906dfe --- /dev/null +++ b/taia/taia_less.3 @@ -0,0 +1,12 @@ +.TH taia_less 3 +.SH NAME +taia_less \- compare two struct taia +.SH SYNTAX +.B #include + +extern int \fBtaia_less\fP(const struct tai* \fIa\fR, + const struct tai* \fIb\fR); +.SH DESCRIPTION +\fBtaia_less\fR returns 1 if \fIa\fR is less than \fIb\fR, 0 otherwise. +.SH "SEE ALSO" +taia_less(3) diff --git a/taia/taia_now.3 b/taia/taia_now.3 new file mode 100644 index 0000000..f69e1c1 --- /dev/null +++ b/taia/taia_now.3 @@ -0,0 +1,22 @@ +.TH taia_now 3 +.SH NAME +taia_now \- get current time +.SH SYNTAX +.B #include + +extern int \fBtaia_now\fP(struct taia* \fIt\fR); +.SH DESCRIPTION +taia_now puts the current time into \fIt\fR. More precisely: tai_now puts into +\fIt\fR its best guess as to the TAI64NA label for the 1-attosecond interval that +contains the current time. + +This implementation of taia_now assumes that the time_t returned from +the time function represents the number of TAI seconds since 1970-01-01 +00:00:10 TAI. This matches the convention used by the Olson tz library +in ``right'' mode. + +Beware that many clocks are not set accurately, and even the best +scientific clocks are nowhere near 1-attosecond accuracy; however, an +inaccurate clock may still produce reasonably accurate time differences. +.SH "SEE ALSO" +tai_now(3) diff --git a/taia/taia_pack.3 b/taia/taia_pack.3 new file mode 100644 index 0000000..21dd058 --- /dev/null +++ b/taia/taia_pack.3 @@ -0,0 +1,14 @@ +.TH taia_pack 3 +.SH NAME +taia_pack \- convert to external TAI64NA format +.SH SYNTAX +.B #include + +extern int \fBtaia_pack\fP(char* buf,const struct taia* \fIt\fR); +.SH DESCRIPTION +taia_pack converts a TAI64NA label from internal format in \fIt\fR to external +TAI64NA format in \fIbuf\fR. + +See http://cr.yp.to/libtai/tai64.html +.SH "SEE ALSO" +tai_pack(3), taia_unpack(3) diff --git a/taia/taia_sub.3 b/taia/taia_sub.3 new file mode 100644 index 0000000..6378f27 --- /dev/null +++ b/taia/taia_sub.3 @@ -0,0 +1,13 @@ +.TH taia_sub 3 +.SH NAME +taia_sub \- subtract two struct taia +.SH SYNTAX +.B #include + +extern int \fBtaia_sub\fP(struct taia* \fIt\fR,const struct taia* \fIa\fR, + const struct taia* \fIb\fR); +.SH DESCRIPTION +\fBtaia_sub\fR subtracts \fIb\fR from \fIa\fR and writes the result to \fIt\fR. +The inputs and output may overlap. +.SH "SEE ALSO" +tai_sub(3), taia_add(3) diff --git a/taia/taia_tai.3 b/taia/taia_tai.3 new file mode 100644 index 0000000..47f1c2b --- /dev/null +++ b/taia/taia_tai.3 @@ -0,0 +1,11 @@ +.TH taia_tai 3 +.SH NAME +taia_tai \- get current time +.SH SYNTAX +.B #include + +extern int \fBtaia_tai\fP(const struct taia* \fIt\fR,struct tai* \fIsec\fR); +.SH DESCRIPTION +taia_tai places into \fIsec\fR the integer part of \fIt\fR. If \fIt\fR +contains a TAI64NA label then \fIsec\fR will contain the corresponding +TAI64 label. diff --git a/taia/taia_uint.3 b/taia/taia_uint.3 new file mode 100644 index 0000000..40d1628 --- /dev/null +++ b/taia/taia_uint.3 @@ -0,0 +1,10 @@ +.TH taia_uint 3 +.SH NAME +taia_uint \- convert seconds into struct taia +.SH SYNTAX +.B #include + +extern int \fBtaia_uint\fP(struct taia* \fIt\fR,unsigned int \fIsecs\fR); +.SH DESCRIPTION +taia_uint converts \fIsecs\fR into a struct taia (setting the fractional +part to zero). diff --git a/taia/taia_unpack.3 b/taia/taia_unpack.3 new file mode 100644 index 0000000..2708998 --- /dev/null +++ b/taia/taia_unpack.3 @@ -0,0 +1,12 @@ +.TH taia_unpack 3 +.SH NAME +taia_unpack \- convert to external TAI64NA format +.SH SYNTAX +.B #include + +extern int \fBtaia_unpack\fP(const char* buf,struct taia* \fIt\fR); +.SH DESCRIPTION +taia_unpack converts a TAI64NA label from external TAI64NA format in +\fIbuf\fR to internal format in \fIt\fR. +.SH "SEE ALSO" +tai_unpack(3), taia_pack(3) diff --git a/taia/taia_unpack.c b/taia/taia_unpack.c new file mode 100644 index 0000000..b1de093 --- /dev/null +++ b/taia/taia_unpack.c @@ -0,0 +1,22 @@ +#include "taia.h" + +void taia_unpack(s,t) +char *s; +struct taia *t; +{ + unsigned long x; + + tai_unpack(s,&t->sec); + s += 8; + + x = (unsigned char) s[4]; + x <<= 8; x += (unsigned char) s[5]; + x <<= 8; x += (unsigned char) s[6]; + x <<= 8; x += (unsigned char) s[7]; + t->atto = x; + x = (unsigned char) s[0]; + x <<= 8; x += (unsigned char) s[1]; + x <<= 8; x += (unsigned char) s[2]; + x <<= 8; x += (unsigned char) s[3]; + t->nano = x; +} diff --git a/test/dnsip.c b/test/dnsip.c new file mode 100644 index 0000000..0f7d6e0 --- /dev/null +++ b/test/dnsip.c @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include + +int main(int argc,char* argv[]) { + static char seed[128]; + static stralloc fqdn; + static stralloc out; + char str[IP4_FMT]; + int i; + + dns_random_init(seed); + if (*argv) ++argv; + while (*argv) { + if (!stralloc_copys(&fqdn,*argv)) { + buffer_putsflush(buffer_2,"out of memory\n"); + return 111; + } + if (dns_ip4(&out,&fqdn) == -1) { + buffer_puts(buffer_2,"unable to find IP address for "); + buffer_puts(buffer_2,*argv); + buffer_puts(buffer_2,": "); + buffer_puts(buffer_2,strerror(errno)); + buffer_putnlflush(buffer_2); + return 111; + } + + for (i = 0;i + 4 <= out.len;i += 4) { + buffer_put(buffer_1,str,ip4_fmt(str,out.s + i)); + buffer_puts(buffer_1," "); + } + buffer_puts(buffer_1,"\n"); + ++argv; + } + buffer_flush(buffer_1); + return 0; +} diff --git a/unix/iopause.3 b/unix/iopause.3 new file mode 100644 index 0000000..6acf23d --- /dev/null +++ b/unix/iopause.3 @@ -0,0 +1,51 @@ +.TH iopause 3 +.SH NAME +iopause \- +.SH SYNTAX +.B #include + +int \fBiopause\fP(iopause_fd** \fIx\fR,unsigned int \fIlen\fR, + struct taia \fIdeadline\fR,struct taia \fIstamp\fR); +.SH DESCRIPTION +iopause checks for file descriptor readability or writability as specified +by \fIx\fR[0].fd, \fIx\fR[0].events, \fIx\fR[1].fd, \fIx\fR[1].events, ..., \fIx\fR[\fIlen\fR-1].fd, +\fIx\fR[\fIlen\fR-1].events. If \fIx\fR[i].events includes the bit IOPAUSE_READ, iopause +checks for readability of the descriptor \fIx\fR[i].fd; if \fIx\fR[i].events includes +the bit IOPAUSE_WRITE, iopause checks for writability of the descriptor +\fIx\fR[i].fd; other bits in \fIx\fR[i].events have undefined effects. + +iopause sets the IOPAUSE_READ bit in \fIx\fR[i].revents if it finds that \fIx\fR[i].fd +is readable, and it sets the IOPAUSE_WRITE bit in \fIx\fR[i].revents if it finds +that \fIx\fR[i].fd is writable. Beware that readability and writability may be +destroyed at any moment by other processes with access to the same ofile +that \fIx\fR[i].fd refers to. + +If there is no readability or writability to report, iopause waits until +\fIdeadline\fR for something to happen. iopause will return before \fIdeadline\fR if a +descriptor becomes readable or writable, or an interrupting signal +arrives, or some system-defined amount of time passes. iopause sets +revents in any case. + +You must put a current timestamp into \fIstamp\fR before calling iopause. +.SH "IMPLEMENTATION NOTES" +The current implementation of iopause uses the \fBpoll\fR function if that is +available. On some systems, \fBpoll\fR needs to dynamically allocate kernel +memory; when not much memory is available, iopause will return +immediately, and will report (often incorrectly) that no descriptors are +readable or writable. This is a kernel bug, and I encourage vendors to fix +it. + +If \fBpoll\fR is not available, iopause uses the \fBselect\fR function. This function +cannot see descriptor numbers past a system-defined limit, typically 256 +or 1024; iopause will artificially pretend that those descriptors are +never readable or writable. + +Future implementations of iopause may work around these problems on some +systems, at the expense of chewing up all available CPU time. + +Both \fBpoll\fR and \fBselect\fR use relative timeouts rather than absolute deadlines. +Some kernels round the timeout down to a multiple of 10 milliseconds; this +can burn quite a bit of CPU time as the deadline approaches. iopause +compensates for this by adding 20 milliseconds to the timeout. +.SH "SEE ALSO" +select(2), poll(3), taia_now(3)