Plan 9 from Bell Labs 2007-03-13

dist/replica/_plan9.db

@@ -22,21 +22,21 @@
 386/bin/acid - 775 sys sys 1172808055 401961
 386/bin/acme - 775 sys sys 1168402263 432256
 386/bin/ape - 20000000775 sys sys 1016944144 0
-386/bin/ape/basename - 775 sys sys 1173039777 134719
+386/bin/ape/basename - 775 sys sys 1173754547 134719
 386/bin/ape/cc - 775 sys sys 1168402263 70642
-386/bin/ape/diff - 775 sys sys 1173039778 352264
-386/bin/ape/diff3 - 775 sys sys 1173039779 190364
-386/bin/ape/dirname - 775 sys sys 1173039779 134498
-386/bin/ape/expr - 775 sys sys 1173039780 144138
-386/bin/ape/kill - 775 sys sys 1173039781 140067
-386/bin/ape/make - 775 sys sys 1173039781 211605
-386/bin/ape/patch - 775 sys sys 1173039782 305848
+386/bin/ape/diff - 775 sys sys 1173754548 352264
+386/bin/ape/diff3 - 775 sys sys 1173754549 190364
+386/bin/ape/dirname - 775 sys sys 1173754549 134498
+386/bin/ape/expr - 775 sys sys 1173754549 144138
+386/bin/ape/kill - 775 sys sys 1173754550 140067
+386/bin/ape/make - 775 sys sys 1173754550 211605
+386/bin/ape/patch - 775 sys sys 1173754551 305848
 386/bin/ape/psh - 775 sys sys 1042220689 34
-386/bin/ape/sed - 775 sys sys 1173039783 160183
-386/bin/ape/sh - 775 sys sys 1173039783 481732
+386/bin/ape/sed - 775 sys sys 1173754551 160183
+386/bin/ape/sh - 775 sys sys 1173754552 481732
 386/bin/ape/stty - 775 sys sys 1148500571 41080
 386/bin/ape/tar - 775 sys sys 1168402264 62184
-386/bin/ape/uname - 775 sys sys 1173039784 134895
+386/bin/ape/uname - 775 sys sys 1173754552 134895
 386/bin/aquarela - 775 sys sys 1169612017 332788
 386/bin/ar - 775 sys sys 1168402265 113774
 386/bin/archfs - 775 sys sys 1168402265 147070
@@ -108,10 +108,10 @@
 386/bin/aux/hardcopy - 775 sys sys 1020319063 1699
 386/bin/aux/isvmware - 775 sys sys 1032486791 23997
 386/bin/aux/lines - 775 sys sys 1168402281 60716
-386/bin/aux/listen - 775 sys sys 1168402281 108803
+386/bin/aux/listen - 775 sys sys 1173754552 108570
 386/bin/aux/listen1 - 775 sys sys 1168402281 94721
-386/bin/aux/lpdaemon - 775 sys sys 1173039785 170710
-386/bin/aux/lpdsend - 775 sys sys 1173039785 157339
+386/bin/aux/lpdaemon - 775 sys sys 1173754553 170710
+386/bin/aux/lpdsend - 775 sys sys 1173754553 157339
 386/bin/aux/lpsend - 775 sys sys 1148500596 52590
 386/bin/aux/mapd - 775 sys sys 1168402282 191082
 386/bin/aux/mkflashfs - 775 sys sys 1168402282 67590
@@ -157,7 +157,7 @@
 386/bin/aux/write - 775 sys sys 1085077011 4188
 386/bin/aux/zerotrunc - 775 sys sys 1108268388 3891
 386/bin/awd - 775 sys sys 1168402289 58975
-386/bin/awk - 775 sys sys 1173039786 324980
+386/bin/awk - 775 sys sys 1173754554 324980
 386/bin/basename - 775 sys sys 1148500606 37919
 386/bin/bc - 775 sys sys 1168402290 82001
 386/bin/bind - 775 sys sys 1168402290 59805
@@ -186,7 +186,7 @@
 386/bin/col - 775 sys sys 1172029864 64995
 386/bin/colors - 775 sys sys 1168402296 150967
 386/bin/comm - 775 sys sys 1168402296 61586
-386/bin/compress - 775 sys sys 1173039787 166944
+386/bin/compress - 775 sys sys 1173754554 166944
 386/bin/con - 775 sys sys 1168402297 78486
 386/bin/cp - 775 sys sys 1168402297 63454
 386/bin/cpp - 775 sys sys 1168402297 150459
@@ -223,7 +223,7 @@
 386/bin/du - 775 sys sys 1168402304 74244
 386/bin/echo - 775 sys sys 1168402304 57592
 386/bin/ed - 775 sys sys 1168402304 93272
-386/bin/eqn - 775 sys sys 1173039787 244858
+386/bin/eqn - 775 sys sys 1173754555 244858
 386/bin/execnet - 775 sys sys 1168402305 178216
 386/bin/exportfs - 775 sys sys 1168402305 162550
 386/bin/ext2srv - 775 sys sys 1168402306 179893
@@ -235,9 +235,9 @@
 386/bin/fortune - 775 sys sys 1168402308 67356
 386/bin/fossil - 20000000775 sys sys 1042005470 0
 386/bin/fossil/conf - 775 sys sys 1085077052 1506
-386/bin/fossil/flchk - 775 sys sys 1168402308 239004
+386/bin/fossil/flchk - 775 sys sys 1173754556 239100
 386/bin/fossil/flfmt - 775 sys sys 1168402309 247151
-386/bin/fossil/fossil - 775 sys sys 1168402310 364442
+386/bin/fossil/fossil - 775 sys sys 1173754557 364538
 386/bin/fossil/last - 775 sys sys 1168402310 63550
 386/bin/freq - 775 sys sys 1168402310 62040
 386/bin/fs - 20000000775 sys sys 954380769 0
@@ -264,10 +264,10 @@
 386/bin/games/sudoku - 775 sys sys 1117249746 171666
 386/bin/getmap - 775 sys sys 1168402311 65423
 386/bin/gif - 775 sys sys 1168402312 158555
-386/bin/grap - 775 sys sys 1173039788 282722
+386/bin/grap - 775 sys sys 1173754557 282722
 386/bin/graph - 775 sys sys 1168402312 129250
 386/bin/grep - 775 sys sys 1168402312 79569
-386/bin/gs - 775 sys sys 1173039815 13278932
+386/bin/gs - 775 sys sys 1173754582 13278932
 386/bin/gunzip - 775 sys sys 1168402313 80523
 386/bin/gview - 775 sys sys 1168402313 238983
 386/bin/gzip - 775 sys sys 1168402313 84984
@@ -534,7 +534,7 @@
 386/lib - 20000000775 sys sys 1016826328 0
 386/lib/ape - 20000000775 sys sys 1070519112 0
 386/lib/ape/lib9.a - 664 sys sys 1135531447 6906
-386/lib/ape/libap.a - 664 sys sys 1173410635 783116
+386/lib/ape/libap.a - 664 sys sys 1173754584 819938
 386/lib/ape/libbsd.a - 664 sys sys 1146156978 183900
 386/lib/ape/libdraw.a - 664 sys sys 1155491760 621772
 386/lib/ape/libfmt.a - 664 sys sys 1146156980 156706
@@ -1396,7 +1396,7 @@ lib/face/48x48x4/x/xigh.1 - 664 sys sys 1142019024 1204
 lib/face/48x48x4/y - 20000000775 sys sys 1020895714 0
 lib/face/48x48x4/z - 20000000775 sys sys 1020895714 0
 lib/face/48x48x8 - 20000000775 sys sys 1123100641 0
-lib/face/48x48x8/.dict - 664 sys sys 1172265593 2972
+lib/face/48x48x8/.dict - 664 sys sys 1173737462 3000
 lib/face/48x48x8/Z - 20000000775 sys sys 1020895714 0
 lib/face/48x48x8/a - 20000000775 sys sys 1056983599 0
 lib/face/48x48x8/a/alu.1 - 664 sys sys 1172265619 1719
@@ -1415,6 +1415,7 @@ lib/face/48x48x8/e - 20000000775 sys sys 1155331573 0
 lib/face/48x48x8/e/ericvh.2 - 664 sys sys 1155331573 1049
 lib/face/48x48x8/f - 20000000775 sys sys 1155331586 0
 lib/face/48x48x8/f/faa.1 - 664 sys sys 1172265611 2013
+lib/face/48x48x8/f/fgb.1 - 664 sys sys 1173737473 2966
 lib/face/48x48x8/f/forsyth.1 - 664 sys sys 1056982111 1864
 lib/face/48x48x8/f/fst.1 - 664 sys sys 1157149515 1099
 lib/face/48x48x8/g - 20000000775 sys sys 1140276024 0
@@ -5227,7 +5228,7 @@ lib/tftpd - 20000000775 sys sys 1020895767 0
 lib/unicode - 664 sys sys 958440028 223312
 lib/unicode.notice - 664 sys sys 958504386 1398
 lib/units - 664 sys sys 1071415518 9997
-lib/vgadb - 664 sys sys 1170456084 30303
+lib/vgadb - 664 sys sys 1173737426 30457
 lib/volcanoes - 664 sys sys 944944024 119831
 lib/words - 664 sys sys 1014923442 247097
 lp - 20000000775 sys sys 1079376135 0
@@ -5450,7 +5451,7 @@ rc/bin/dosmnt - 775 sys sys 1109288224 303
 rc/bin/eject - 775 sys sys 945617207 123
 rc/bin/fax - 775 sys sys 1127394677 2385
 rc/bin/fedex - 775 sys sys 1060187356 1244
-rc/bin/fshalt - 775 sys sys 1169491261 1401
+rc/bin/fshalt - 775 sys sys 1173737783 1652
 rc/bin/homespool - 775 sys sys 945617207 339
 rc/bin/ipconf - 20000000775 sys sys 1058791152 0
 rc/bin/ipconf/inside - 775 sys sys 1058790955 427
@@ -5462,13 +5463,13 @@ rc/bin/iwhois - 775 sys sys 1143979502 1637
 rc/bin/juke - 775 sys sys 1105565140 1131
 rc/bin/kill - 775 sys sys 1143389260 142
 rc/bin/kmem - 775 sys sys 1141940177 468
-rc/bin/label - 775 sys sys 1173121903 113
+rc/bin/label - 775 sys sys 1173737765 189
 rc/bin/lc - 775 sys sys 945617207 24
 rc/bin/leak - 775 sys sys 1172760642 1921
 rc/bin/lookman - 775 sys sys 1017679344 686
 rc/bin/lp - 775 sys sys 1162105982 5201
 rc/bin/mail - 775 sys sys 1045504003 138
-rc/bin/man - 775 sys sys 1172005212 2494
+rc/bin/man - 775 sys sys 1173755398 2504
 rc/bin/map - 775 sys sys 945617207 1576
 rc/bin/mapdemo - 775 sys sys 945617207 4075
 rc/bin/membername - 775 sys sys 945617207 89
@@ -5768,7 +5769,7 @@ sys/games - 20000000775 sys sys 1117225532 0
 sys/games/lib - 20000000775 sys sys 1165337608 0
 sys/games/lib/4scores - 10000000666 sys sys 1118680448 0
 sys/games/lib/5scores - 10000000666 sys sys 1118680453 0
-sys/games/lib/fortunes - 664 sys sys 1173279478 263737
+sys/games/lib/fortunes - 664 sys sys 1173736758 264000
 sys/games/lib/mahjongg - 20000000775 sys sys 1095792278 0
 sys/games/lib/mahjongg/backgrounds - 20000000775 sys sys 1095792293 0
 sys/games/lib/mahjongg/backgrounds/default.bit - 664 sys sys 1095792293 346803
@@ -6142,7 +6143,7 @@ sys/lib/dist/cmd/touchfs.c - 664 sys sys 1018469727 1120
 sys/lib/dist/cmd/unbflz.c - 664 sys sys 1018469727 1688
 sys/lib/dist/logcompress.awk - 664 sys sys 1068558028 298
 sys/lib/dist/logtime.awk - 664 sys sys 1019526213 38
-sys/lib/dist/mkfile - 664 sys sys 1168307719 5076
+sys/lib/dist/mkfile - 664 sys sys 1173736647 5154
 sys/lib/dist/pc - 20000000775 sys sys 1147022870 0
 sys/lib/dist/pc/cd0.proto - 664 sys sys 1114358485 7
 sys/lib/dist/pc/empty - 20000000775 sys sys 1020895854 0
@@ -7731,6 +7732,7 @@ sys/man/8/drawterm - 664 sys sys 1135901219 1741
 sys/man/8/fossilcons - 664 sys sys 1155362671 18291
 sys/man/8/fs - 664 sys sys 1172956177 15086
 sys/man/8/fsconfig - 664 sys sys 1172956534 8878
+sys/man/8/fshalt - 664 sys sys 1173737264 862
 sys/man/8/getflags - 664 sys sys 1159419702 1713
 sys/man/8/gpsfs - 664 sys sys 1165623047 4918
 sys/man/8/httpd - 664 sys sys 1165623004 6865
@@ -7738,7 +7740,7 @@ sys/man/8/init - 664 sys sys 944959679 1430
 sys/man/8/ipconfig - 664 sys sys 1159419702 6170
 sys/man/8/ipserv - 664 sys sys 1095862383 4375
 sys/man/8/kfscmd - 664 sys sys 1068569797 4515
-sys/man/8/listen - 664 sys sys 1164653967 3551
+sys/man/8/listen - 664 sys sys 1173736981 3562
 sys/man/8/lp - 664 sys sys 954614702 2491
 sys/man/8/mk9660 - 664 sys sys 1104430379 3946
 sys/man/8/mkfs - 664 sys sys 1163208436 3414
@@ -8680,7 +8682,7 @@ sys/src/ape/lib/ap/plan9/getpwnam.c - 664 sys sys 1014921984 507
 sys/src/ape/lib/ap/plan9/getpwuid.c - 664 sys sys 1014921984 527
 sys/src/ape/lib/ap/plan9/getuid.c - 664 sys sys 1014921984 199
 sys/src/ape/lib/ap/plan9/isatty.c - 664 sys sys 1014921984 471
-sys/src/ape/lib/ap/plan9/kill.c - 664 sys sys 1173022765 911
+sys/src/ape/lib/ap/plan9/kill.c - 664 sys sys 1173736785 912
 sys/src/ape/lib/ap/plan9/lib.h - 664 sys sys 1072835434 2071
 sys/src/ape/lib/ap/plan9/link.c - 664 sys sys 1014921984 168
 sys/src/ape/lib/ap/plan9/lseek.c - 664 sys sys 1038237526 358
@@ -8833,8 +8835,8 @@ sys/src/ape/lib/ap/stdio/vprintf.c - 664 sys sys 1014921983 134
 sys/src/ape/lib/ap/stdio/vsnprintf.c - 664 sys sys 1134052382 267
 sys/src/ape/lib/ap/stdio/vsprintf.c - 664 sys sys 1134052382 254
 sys/src/ape/lib/ap/syscall - 20000000775 sys sys 1039727535 0
-sys/src/ape/lib/ap/syscall/geninstall - 775 sys sys 1173384418 425
-sys/src/ape/lib/ap/syscall/mkfile - 664 sys sys 1173384418 164
+sys/src/ape/lib/ap/syscall/genall - 775 sys sys 1173737406 520
+sys/src/ape/lib/ap/syscall/mkfile - 664 sys sys 1173737407 489
 sys/src/ape/lib/bsd - 20000000775 sys sys 1063858406 0
 sys/src/ape/lib/bsd/_sock_ingetaddr.c - 664 sys sys 1014921994 836
 sys/src/ape/lib/bsd/_sock_ipattr.c - 664 sys sys 1014921994 577
@@ -9679,7 +9681,7 @@ sys/src/cmd/aux/gps/mkfile - 664 sys sys 1108397331 219
 sys/src/cmd/aux/gps/util.c - 664 sys sys 1107448815 2795
 sys/src/cmd/aux/lines.c - 664 sys sys 1015008782 546
 sys/src/cmd/aux/lis - 775 sys sys 944960794 45
-sys/src/cmd/aux/listen.c - 664 sys sys 1164653434 8796
+sys/src/cmd/aux/listen.c - 664 sys sys 1173736994 8997
 sys/src/cmd/aux/listen1.c - 664 sys sys 1143759349 2005
 sys/src/cmd/aux/mkfile - 664 sys sys 1147022848 1021
 sys/src/cmd/aux/mklatinkbd.c - 664 sys sys 953253425 3813
@@ -10194,7 +10196,7 @@ sys/src/cmd/fossil/build - 664 sys sys 1042005505 449
 sys/src/cmd/fossil/buildsh - 775 sys sys 1042005505 561
 sys/src/cmd/fossil/bwatch.c - 664 sys sys 1042005505 6754
 sys/src/cmd/fossil/cache.c - 664 sys sys 1143759345 43875
-sys/src/cmd/fossil/check.c - 664 sys sys 1091904423 17315
+sys/src/cmd/fossil/check.c - 664 sys sys 1173736846 17436
 sys/src/cmd/fossil/conf.rc - 775 sys sys 1084333190 1416
 sys/src/cmd/fossil/dat.h - 664 sys sys 1158373945 7622
 sys/src/cmd/fossil/deadlock - 775 sys sys 1042005506 413
@@ -10208,7 +10210,7 @@ sys/src/cmd/fossil/flchk.c - 664 sys sys 1087005592 1771
 sys/src/cmd/fossil/flfmt.c - 664 sys sys 1080586881 10753
 sys/src/cmd/fossil/flfmt9660.c - 664 sys sys 1132451844 12318
 sys/src/cmd/fossil/flfmt9660.h - 664 sys sys 1072830621 134
-sys/src/cmd/fossil/flproto - 664 sys sys 1042005508 210
+sys/src/cmd/fossil/flproto - 664 sys sys 1173736837 222
 sys/src/cmd/fossil/fns.h - 664 sys sys 1139667257 3228
 sys/src/cmd/fossil/fossil-acid - 664 sys sys 1139667278 4365
 sys/src/cmd/fossil/fossil.c - 664 sys sys 1077896345 2435
@@ -12653,7 +12655,7 @@ sys/src/cmd/mk/var.c - 664 sys sys 1131289510 530
 sys/src/cmd/mk/varsub.c - 664 sys sys 1131289511 4425
 sys/src/cmd/mk/word.c - 664 sys sys 944961025 2595
 sys/src/cmd/mkdir.c - 664 sys sys 1082593106 1026
-sys/src/cmd/mkfile - 664 sys sys 1142958953 2451
+sys/src/cmd/mkfile - 664 sys sys 1173736967 2618
 sys/src/cmd/mklib - 664 sys sys 1101213349 618
 sys/src/cmd/mkmany - 664 sys sys 1123818681 1304
 sys/src/cmd/mkone - 664 sys sys 1123943673 910
@@ -12665,28 +12667,30 @@ sys/src/cmd/mtime.c - 664 sys sys 1036172302 450
 sys/src/cmd/mug.c - 664 sys sys 1157143847 24888
 sys/src/cmd/mv.c - 664 sys sys 1163029439 4682
 sys/src/cmd/ndb - 20000000775 sys sys 1080135004 0
-sys/src/cmd/ndb/convDNS2M.c - 664 sys sys 1173059857 6856
-sys/src/cmd/ndb/convM2DNS.c - 664 sys sys 1173335487 10645
-sys/src/cmd/ndb/cs.c - 664 sys sys 1163208617 33080
-sys/src/cmd/ndb/csquery.c - 664 sys sys 1173401775 1073
-sys/src/cmd/ndb/dblookup.c - 664 sys sys 1173335538 18207
-sys/src/cmd/ndb/dn.c - 664 sys sys 1173239201 32107
-sys/src/cmd/ndb/dnarea.c - 664 sys sys 1173059947 2517
-sys/src/cmd/ndb/dnnotify.c - 664 sys sys 1173238959 3158
-sys/src/cmd/ndb/dnresolve.c - 664 sys sys 1173401935 22144
-sys/src/cmd/ndb/dns.c - 664 sys sys 1173401831 15957
-sys/src/cmd/ndb/dns.h - 664 sys sys 1173335529 9992
-sys/src/cmd/ndb/dnsdebug.c - 664 sys sys 1173401872 8650
-sys/src/cmd/ndb/dnserver.c - 664 sys sys 1173335425 4431
-sys/src/cmd/ndb/dnsquery.c - 664 sys sys 1173401783 2199
-sys/src/cmd/ndb/dnstcp.c - 664 sys sys 1173401840 7704
-sys/src/cmd/ndb/dnudpserver.c - 664 sys sys 1173335517 5678
-sys/src/cmd/ndb/ipquery.c - 664 sys sys 1124711426 773
+sys/src/cmd/ndb/convDNS2M.c - 664 sys sys 1117253517 6866
+sys/src/cmd/ndb/convM2DNS.c - 664 sys sys 1060612175 7248
+sys/src/cmd/ndb/cs.c - 664 sys sys 1163208159 33080
+sys/src/cmd/ndb/csquery.c - 664 sys sys 1014926159 1062
+sys/src/cmd/ndb/dblookup.c - 664 sys sys 1143749799 18249
+sys/src/cmd/ndb/dn.acid - 664 sys sys 1144950752 20174
+sys/src/cmd/ndb/dn.c - 664 sys sys 1144952448 28763
+sys/src/cmd/ndb/dnarea.c - 664 sys sys 1121972945 2128
+sys/src/cmd/ndb/dnnotify.c - 664 sys sys 1144952457 3066
+sys/src/cmd/ndb/dnresolve.c - 664 sys sys 1166760846 15351
+sys/src/cmd/ndb/dns.c - 664 sys sys 1146746848 15309
+sys/src/cmd/ndb/dns.h - 664 sys sys 1144952221 10171
+sys/src/cmd/ndb/dnsdebug.c - 664 sys sys 1144952322 8492
+sys/src/cmd/ndb/dnserver.c - 664 sys sys 1143648239 3982
+sys/src/cmd/ndb/dnsquery.c - 664 sys sys 1120564707 2198
+sys/src/cmd/ndb/dnstcp.c - 664 sys sys 1144952355 7349
+sys/src/cmd/ndb/dnudpserver.c - 664 sys sys 1144969068 5337
+sys/src/cmd/ndb/ipquery.c - 664 sys sys 1124711423 773
 sys/src/cmd/ndb/mkdb.c - 664 sys sys 957402054 2886
-sys/src/cmd/ndb/mkfile - 664 sys sys 1173059600 1984
+sys/src/cmd/ndb/mkfile - 664 sys sys 1055701930 1877
 sys/src/cmd/ndb/mkhash.c - 664 sys sys 1014926160 2899
 sys/src/cmd/ndb/mkhosts.c - 664 sys sys 957402054 4294
-sys/src/cmd/ndb/query.c - 664 sys sys 1173239042 1137
+sys/src/cmd/ndb/query.c - 664 sys sys 1078782843 1120
+sys/src/cmd/ndb/time.c - 664 sys sys 957402055 321
 sys/src/cmd/netstat.c - 664 sys sys 1128255434 4086
 sys/src/cmd/news.c - 664 sys sys 1014926614 3778
 sys/src/cmd/nfs.c - 664 sys sys 1050068720 31096
@@ -14370,7 +14374,7 @@ sys/src/fs/dev - 20000000775 sys sys 1140168396 0
 sys/src/fs/dev/apc.c - 664 sys sys 1140167918 14910
 sys/src/fs/dev/cw.c - 664 sys sys 1097712558 43252
 sys/src/fs/dev/fworm.c - 664 sys sys 1140167912 1845
-sys/src/fs/dev/juke.c - 664 sys sys 1097578476 22885
+sys/src/fs/dev/juke.c - 664 sys sys 1173736142 22905
 sys/src/fs/dev/mkfile - 664 sys sys 1015109974 132
 sys/src/fs/dev/mworm.c - 664 sys sys 1140167915 4264
 sys/src/fs/dev/wren.c - 664 sys sys 1140167916 2392
@@ -14440,7 +14444,7 @@ sys/src/fs/pc/ethermii.h - 664 sys sys 1140167955 3259
 sys/src/fs/pc/floppy.c - 664 sys sys 1097579636 14022
 sys/src/fs/pc/kbd.c - 664 sys sys 1015110060 6030
 sys/src/fs/pc/l.s - 664 sys sys 1096008336 10838
-sys/src/fs/pc/lock.c - 664 sys sys 1045502910 3591
+sys/src/fs/pc/lock.c - 664 sys sys 1173736177 3672
 sys/src/fs/pc/malloc.c - 664 sys sys 1096789023 2840
 sys/src/fs/pc/mkfile - 664 sys sys 1140167942 426
 sys/src/fs/pc/mmu.c - 664 sys sys 1015110065 8414
@@ -14465,7 +14469,7 @@ sys/src/fs/port/all.h - 664 sys sys 1146798594 1888
 sys/src/fs/port/auth.c - 664 sys sys 1146785221 7606
 sys/src/fs/port/chk.c - 664 sys sys 1097832483 15683
 sys/src/fs/port/clock.c - 664 sys sys 1097580538 4033
-sys/src/fs/port/con.c - 664 sys sys 1146785256 16304
+sys/src/fs/port/con.c - 664 sys sys 1173736129 16296
 sys/src/fs/port/config.c - 664 sys sys 1157944410 20574
 sys/src/fs/port/console.c - 664 sys sys 1101627646 4886
 sys/src/fs/port/data.c - 664 sys sys 1140167986 4510
@@ -14485,7 +14489,7 @@ sys/src/fs/port/print.c - 664 sys sys 1015110022 153
 sys/src/fs/port/proc.c - 664 sys sys 1097580775 5364
 sys/src/fs/port/sd.h - 664 sys sys 1140774087 2305
 sys/src/fs/port/sub.c - 664 sys sys 1151380380 25860
-sys/src/fs/port/time.c - 664 sys sys 1140167998 6222
+sys/src/fs/port/time.c - 664 sys sys 1173736121 6443
 sys/src/fs/port/uidgid.c - 664 sys sys 1097574050 9192
 sys/src/games - 20000000775 sys sys 1128271724 0
 sys/src/games/4s.c - 664 sys sys 1128271724 1285
@@ -14828,7 +14832,7 @@ sys/src/libc/9sys/werrstr.c - 664 sys sys 1014927340 196
 sys/src/libc/9sys/write.c - 664 sys sys 1014927340 110
 sys/src/libc/9sys/writev.c - 664 sys sys 1014927340 577
 sys/src/libc/9syscall - 20000000775 sys sys 1062619381 0
-sys/src/libc/9syscall/mkfile - 664 sys sys 1173374403 2891
+sys/src/libc/9syscall/mkfile - 664 sys sys 1173737379 2800
 sys/src/libc/9syscall/sys.h - 664 sys sys 1143129935 927
 sys/src/libc/alpha - 20000000775 sys sys 1067718982 0
 sys/src/libc/alpha/_seek.c - 664 sys sys 1130424714 180
@@ -15423,7 +15427,7 @@ sys/src/libndb/ndbhash.c - 664 sys sys 1144174490 5276
 sys/src/libndb/ndbhf.h - 664 sys sys 1015013485 746
 sys/src/libndb/ndbipinfo.c - 664 sys sys 1157899101 5127
 sys/src/libndb/ndblookval.c - 664 sys sys 1078839929 791
-sys/src/libndb/ndbopen.c - 664 sys sys 1069206441 2716
+sys/src/libndb/ndbopen.c - 664 sys sys 1173737251 2717
 sys/src/libndb/ndbparse.c - 664 sys sys 1144174490 1207
 sys/src/libndb/ndbreorder.c - 664 sys sys 1078618600 966
 sys/src/libndb/ndbsubstitute.c - 664 sys sys 1144174491 867
@@ -15682,6 +15686,3 @@ usr/glenda/lib/profile - 664 glenda glenda 1105128663 890
 usr/glenda/readme.acme - 664 glenda glenda 1019860628 4753
 usr/glenda/readme.rio - 664 glenda glenda 1019860628 6370
 usr/glenda/tmp - 20000000775 glenda glenda 1018802620 0
-sys/src/ape/lib/ap/syscall/genall - 775 sys sys 1173413221 383
-sys/src/ape/lib/ap/syscall/mkfile - 664 sys sys 1173413222 351
-sys/src/ape/lib/ap/syscall/geninstall xxx REMOVED xxx xxx 0 0

dist/replica/plan9.db

@@ -22,21 +22,21 @@
 386/bin/acid - 775 sys sys 1172808055 401961
 386/bin/acme - 775 sys sys 1168402263 432256
 386/bin/ape - 20000000775 sys sys 1016944144 0
-386/bin/ape/basename - 775 sys sys 1173039777 134719
+386/bin/ape/basename - 775 sys sys 1173754547 134719
 386/bin/ape/cc - 775 sys sys 1168402263 70642
-386/bin/ape/diff - 775 sys sys 1173039778 352264
-386/bin/ape/diff3 - 775 sys sys 1173039779 190364
-386/bin/ape/dirname - 775 sys sys 1173039779 134498
-386/bin/ape/expr - 775 sys sys 1173039780 144138
-386/bin/ape/kill - 775 sys sys 1173039781 140067
-386/bin/ape/make - 775 sys sys 1173039781 211605
-386/bin/ape/patch - 775 sys sys 1173039782 305848
+386/bin/ape/diff - 775 sys sys 1173754548 352264
+386/bin/ape/diff3 - 775 sys sys 1173754549 190364
+386/bin/ape/dirname - 775 sys sys 1173754549 134498
+386/bin/ape/expr - 775 sys sys 1173754549 144138
+386/bin/ape/kill - 775 sys sys 1173754550 140067
+386/bin/ape/make - 775 sys sys 1173754550 211605
+386/bin/ape/patch - 775 sys sys 1173754551 305848
 386/bin/ape/psh - 775 sys sys 1042220689 34
-386/bin/ape/sed - 775 sys sys 1173039783 160183
-386/bin/ape/sh - 775 sys sys 1173039783 481732
+386/bin/ape/sed - 775 sys sys 1173754551 160183
+386/bin/ape/sh - 775 sys sys 1173754552 481732
 386/bin/ape/stty - 775 sys sys 1148500571 41080
 386/bin/ape/tar - 775 sys sys 1168402264 62184
-386/bin/ape/uname - 775 sys sys 1173039784 134895
+386/bin/ape/uname - 775 sys sys 1173754552 134895
 386/bin/aquarela - 775 sys sys 1169612017 332788
 386/bin/ar - 775 sys sys 1168402265 113774
 386/bin/archfs - 775 sys sys 1168402265 147070
@@ -108,10 +108,10 @@
 386/bin/aux/hardcopy - 775 sys sys 1020319063 1699
 386/bin/aux/isvmware - 775 sys sys 1032486791 23997
 386/bin/aux/lines - 775 sys sys 1168402281 60716
-386/bin/aux/listen - 775 sys sys 1168402281 108803
+386/bin/aux/listen - 775 sys sys 1173754552 108570
 386/bin/aux/listen1 - 775 sys sys 1168402281 94721
-386/bin/aux/lpdaemon - 775 sys sys 1173039785 170710
-386/bin/aux/lpdsend - 775 sys sys 1173039785 157339
+386/bin/aux/lpdaemon - 775 sys sys 1173754553 170710
+386/bin/aux/lpdsend - 775 sys sys 1173754553 157339
 386/bin/aux/lpsend - 775 sys sys 1148500596 52590
 386/bin/aux/mapd - 775 sys sys 1168402282 191082
 386/bin/aux/mkflashfs - 775 sys sys 1168402282 67590
@@ -157,7 +157,7 @@
 386/bin/aux/write - 775 sys sys 1085077011 4188
 386/bin/aux/zerotrunc - 775 sys sys 1108268388 3891
 386/bin/awd - 775 sys sys 1168402289 58975
-386/bin/awk - 775 sys sys 1173039786 324980
+386/bin/awk - 775 sys sys 1173754554 324980
 386/bin/basename - 775 sys sys 1148500606 37919
 386/bin/bc - 775 sys sys 1168402290 82001
 386/bin/bind - 775 sys sys 1168402290 59805
@@ -186,7 +186,7 @@
 386/bin/col - 775 sys sys 1172029864 64995
 386/bin/colors - 775 sys sys 1168402296 150967
 386/bin/comm - 775 sys sys 1168402296 61586
-386/bin/compress - 775 sys sys 1173039787 166944
+386/bin/compress - 775 sys sys 1173754554 166944
 386/bin/con - 775 sys sys 1168402297 78486
 386/bin/cp - 775 sys sys 1168402297 63454
 386/bin/cpp - 775 sys sys 1168402297 150459
@@ -223,7 +223,7 @@
 386/bin/du - 775 sys sys 1168402304 74244
 386/bin/echo - 775 sys sys 1168402304 57592
 386/bin/ed - 775 sys sys 1168402304 93272
-386/bin/eqn - 775 sys sys 1173039787 244858
+386/bin/eqn - 775 sys sys 1173754555 244858
 386/bin/execnet - 775 sys sys 1168402305 178216
 386/bin/exportfs - 775 sys sys 1168402305 162550
 386/bin/ext2srv - 775 sys sys 1168402306 179893
@@ -235,9 +235,9 @@
 386/bin/fortune - 775 sys sys 1168402308 67356
 386/bin/fossil - 20000000775 sys sys 1042005470 0
 386/bin/fossil/conf - 775 sys sys 1085077052 1506
-386/bin/fossil/flchk - 775 sys sys 1168402308 239004
+386/bin/fossil/flchk - 775 sys sys 1173754556 239100
 386/bin/fossil/flfmt - 775 sys sys 1168402309 247151
-386/bin/fossil/fossil - 775 sys sys 1168402310 364442
+386/bin/fossil/fossil - 775 sys sys 1173754557 364538
 386/bin/fossil/last - 775 sys sys 1168402310 63550
 386/bin/freq - 775 sys sys 1168402310 62040
 386/bin/fs - 20000000775 sys sys 954380769 0
@@ -264,10 +264,10 @@
 386/bin/games/sudoku - 775 sys sys 1117249746 171666
 386/bin/getmap - 775 sys sys 1168402311 65423
 386/bin/gif - 775 sys sys 1168402312 158555
-386/bin/grap - 775 sys sys 1173039788 282722
+386/bin/grap - 775 sys sys 1173754557 282722
 386/bin/graph - 775 sys sys 1168402312 129250
 386/bin/grep - 775 sys sys 1168402312 79569
-386/bin/gs - 775 sys sys 1173039815 13278932
+386/bin/gs - 775 sys sys 1173754582 13278932
 386/bin/gunzip - 775 sys sys 1168402313 80523
 386/bin/gview - 775 sys sys 1168402313 238983
 386/bin/gzip - 775 sys sys 1168402313 84984
@@ -534,7 +534,7 @@
 386/lib - 20000000775 sys sys 1016826328 0
 386/lib/ape - 20000000775 sys sys 1070519112 0
 386/lib/ape/lib9.a - 664 sys sys 1135531447 6906
-386/lib/ape/libap.a - 664 sys sys 1173410635 783116
+386/lib/ape/libap.a - 664 sys sys 1173754584 819938
 386/lib/ape/libbsd.a - 664 sys sys 1146156978 183900
 386/lib/ape/libdraw.a - 664 sys sys 1155491760 621772
 386/lib/ape/libfmt.a - 664 sys sys 1146156980 156706
@@ -1396,7 +1396,7 @@ lib/face/48x48x4/x/xigh.1 - 664 sys sys 1142019024 1204
 lib/face/48x48x4/y - 20000000775 sys sys 1020895714 0
 lib/face/48x48x4/z - 20000000775 sys sys 1020895714 0
 lib/face/48x48x8 - 20000000775 sys sys 1123100641 0
-lib/face/48x48x8/.dict - 664 sys sys 1172265593 2972
+lib/face/48x48x8/.dict - 664 sys sys 1173737462 3000
 lib/face/48x48x8/Z - 20000000775 sys sys 1020895714 0
 lib/face/48x48x8/a - 20000000775 sys sys 1056983599 0
 lib/face/48x48x8/a/alu.1 - 664 sys sys 1172265619 1719
@@ -1415,6 +1415,7 @@ lib/face/48x48x8/e - 20000000775 sys sys 1155331573 0
 lib/face/48x48x8/e/ericvh.2 - 664 sys sys 1155331573 1049
 lib/face/48x48x8/f - 20000000775 sys sys 1155331586 0
 lib/face/48x48x8/f/faa.1 - 664 sys sys 1172265611 2013
+lib/face/48x48x8/f/fgb.1 - 664 sys sys 1173737473 2966
 lib/face/48x48x8/f/forsyth.1 - 664 sys sys 1056982111 1864
 lib/face/48x48x8/f/fst.1 - 664 sys sys 1157149515 1099
 lib/face/48x48x8/g - 20000000775 sys sys 1140276024 0
@@ -5227,7 +5228,7 @@ lib/tftpd - 20000000775 sys sys 1020895767 0
 lib/unicode - 664 sys sys 958440028 223312
 lib/unicode.notice - 664 sys sys 958504386 1398
 lib/units - 664 sys sys 1071415518 9997
-lib/vgadb - 664 sys sys 1170456084 30303
+lib/vgadb - 664 sys sys 1173737426 30457
 lib/volcanoes - 664 sys sys 944944024 119831
 lib/words - 664 sys sys 1014923442 247097
 lp - 20000000775 sys sys 1079376135 0
@@ -5450,7 +5451,7 @@ rc/bin/dosmnt - 775 sys sys 1109288224 303
 rc/bin/eject - 775 sys sys 945617207 123
 rc/bin/fax - 775 sys sys 1127394677 2385
 rc/bin/fedex - 775 sys sys 1060187356 1244
-rc/bin/fshalt - 775 sys sys 1169491261 1401
+rc/bin/fshalt - 775 sys sys 1173737783 1652
 rc/bin/homespool - 775 sys sys 945617207 339
 rc/bin/ipconf - 20000000775 sys sys 1058791152 0
 rc/bin/ipconf/inside - 775 sys sys 1058790955 427
@@ -5462,13 +5463,13 @@ rc/bin/iwhois - 775 sys sys 1143979502 1637
 rc/bin/juke - 775 sys sys 1105565140 1131
 rc/bin/kill - 775 sys sys 1143389260 142
 rc/bin/kmem - 775 sys sys 1141940177 468
-rc/bin/label - 775 sys sys 1173121903 113
+rc/bin/label - 775 sys sys 1173737765 189
 rc/bin/lc - 775 sys sys 945617207 24
 rc/bin/leak - 775 sys sys 1172760642 1921
 rc/bin/lookman - 775 sys sys 1017679344 686
 rc/bin/lp - 775 sys sys 1162105982 5201
 rc/bin/mail - 775 sys sys 1045504003 138
-rc/bin/man - 775 sys sys 1172005212 2494
+rc/bin/man - 775 sys sys 1173755398 2504
 rc/bin/map - 775 sys sys 945617207 1576
 rc/bin/mapdemo - 775 sys sys 945617207 4075
 rc/bin/membername - 775 sys sys 945617207 89
@@ -5768,7 +5769,7 @@ sys/games - 20000000775 sys sys 1117225532 0
 sys/games/lib - 20000000775 sys sys 1165337608 0
 sys/games/lib/4scores - 10000000666 sys sys 1118680448 0
 sys/games/lib/5scores - 10000000666 sys sys 1118680453 0
-sys/games/lib/fortunes - 664 sys sys 1173279478 263737
+sys/games/lib/fortunes - 664 sys sys 1173736758 264000
 sys/games/lib/mahjongg - 20000000775 sys sys 1095792278 0
 sys/games/lib/mahjongg/backgrounds - 20000000775 sys sys 1095792293 0
 sys/games/lib/mahjongg/backgrounds/default.bit - 664 sys sys 1095792293 346803
@@ -6142,7 +6143,7 @@ sys/lib/dist/cmd/touchfs.c - 664 sys sys 1018469727 1120
 sys/lib/dist/cmd/unbflz.c - 664 sys sys 1018469727 1688
 sys/lib/dist/logcompress.awk - 664 sys sys 1068558028 298
 sys/lib/dist/logtime.awk - 664 sys sys 1019526213 38
-sys/lib/dist/mkfile - 664 sys sys 1168307719 5076
+sys/lib/dist/mkfile - 664 sys sys 1173736647 5154
 sys/lib/dist/pc - 20000000775 sys sys 1147022870 0
 sys/lib/dist/pc/cd0.proto - 664 sys sys 1114358485 7
 sys/lib/dist/pc/empty - 20000000775 sys sys 1020895854 0
@@ -7731,6 +7732,7 @@ sys/man/8/drawterm - 664 sys sys 1135901219 1741
 sys/man/8/fossilcons - 664 sys sys 1155362671 18291
 sys/man/8/fs - 664 sys sys 1172956177 15086
 sys/man/8/fsconfig - 664 sys sys 1172956534 8878
+sys/man/8/fshalt - 664 sys sys 1173737264 862
 sys/man/8/getflags - 664 sys sys 1159419702 1713
 sys/man/8/gpsfs - 664 sys sys 1165623047 4918
 sys/man/8/httpd - 664 sys sys 1165623004 6865
@@ -7738,7 +7740,7 @@ sys/man/8/init - 664 sys sys 944959679 1430
 sys/man/8/ipconfig - 664 sys sys 1159419702 6170
 sys/man/8/ipserv - 664 sys sys 1095862383 4375
 sys/man/8/kfscmd - 664 sys sys 1068569797 4515
-sys/man/8/listen - 664 sys sys 1164653967 3551
+sys/man/8/listen - 664 sys sys 1173736981 3562
 sys/man/8/lp - 664 sys sys 954614702 2491
 sys/man/8/mk9660 - 664 sys sys 1104430379 3946
 sys/man/8/mkfs - 664 sys sys 1163208436 3414
@@ -8680,7 +8682,7 @@ sys/src/ape/lib/ap/plan9/getpwnam.c - 664 sys sys 1014921984 507
 sys/src/ape/lib/ap/plan9/getpwuid.c - 664 sys sys 1014921984 527
 sys/src/ape/lib/ap/plan9/getuid.c - 664 sys sys 1014921984 199
 sys/src/ape/lib/ap/plan9/isatty.c - 664 sys sys 1014921984 471
-sys/src/ape/lib/ap/plan9/kill.c - 664 sys sys 1173022765 911
+sys/src/ape/lib/ap/plan9/kill.c - 664 sys sys 1173736785 912
 sys/src/ape/lib/ap/plan9/lib.h - 664 sys sys 1072835434 2071
 sys/src/ape/lib/ap/plan9/link.c - 664 sys sys 1014921984 168
 sys/src/ape/lib/ap/plan9/lseek.c - 664 sys sys 1038237526 358
@@ -8833,8 +8835,8 @@ sys/src/ape/lib/ap/stdio/vprintf.c - 664 sys sys 1014921983 134
 sys/src/ape/lib/ap/stdio/vsnprintf.c - 664 sys sys 1134052382 267
 sys/src/ape/lib/ap/stdio/vsprintf.c - 664 sys sys 1134052382 254
 sys/src/ape/lib/ap/syscall - 20000000775 sys sys 1039727535 0
-sys/src/ape/lib/ap/syscall/genall - 775 sys sys 1173413221 383
-sys/src/ape/lib/ap/syscall/mkfile - 664 sys sys 1173413222 351
+sys/src/ape/lib/ap/syscall/genall - 775 sys sys 1173737406 520
+sys/src/ape/lib/ap/syscall/mkfile - 664 sys sys 1173737407 489
 sys/src/ape/lib/bsd - 20000000775 sys sys 1063858406 0
 sys/src/ape/lib/bsd/_sock_ingetaddr.c - 664 sys sys 1014921994 836
 sys/src/ape/lib/bsd/_sock_ipattr.c - 664 sys sys 1014921994 577
@@ -9679,7 +9681,7 @@ sys/src/cmd/aux/gps/mkfile - 664 sys sys 1108397331 219
 sys/src/cmd/aux/gps/util.c - 664 sys sys 1107448815 2795
 sys/src/cmd/aux/lines.c - 664 sys sys 1015008782 546
 sys/src/cmd/aux/lis - 775 sys sys 944960794 45
-sys/src/cmd/aux/listen.c - 664 sys sys 1164653434 8796
+sys/src/cmd/aux/listen.c - 664 sys sys 1173736994 8997
 sys/src/cmd/aux/listen1.c - 664 sys sys 1143759349 2005
 sys/src/cmd/aux/mkfile - 664 sys sys 1147022848 1021
 sys/src/cmd/aux/mklatinkbd.c - 664 sys sys 953253425 3813
@@ -10194,7 +10196,7 @@ sys/src/cmd/fossil/build - 664 sys sys 1042005505 449
 sys/src/cmd/fossil/buildsh - 775 sys sys 1042005505 561
 sys/src/cmd/fossil/bwatch.c - 664 sys sys 1042005505 6754
 sys/src/cmd/fossil/cache.c - 664 sys sys 1143759345 43875
-sys/src/cmd/fossil/check.c - 664 sys sys 1091904423 17315
+sys/src/cmd/fossil/check.c - 664 sys sys 1173736846 17436
 sys/src/cmd/fossil/conf.rc - 775 sys sys 1084333190 1416
 sys/src/cmd/fossil/dat.h - 664 sys sys 1158373945 7622
 sys/src/cmd/fossil/deadlock - 775 sys sys 1042005506 413
@@ -10208,7 +10210,7 @@ sys/src/cmd/fossil/flchk.c - 664 sys sys 1087005592 1771
 sys/src/cmd/fossil/flfmt.c - 664 sys sys 1080586881 10753
 sys/src/cmd/fossil/flfmt9660.c - 664 sys sys 1132451844 12318
 sys/src/cmd/fossil/flfmt9660.h - 664 sys sys 1072830621 134
-sys/src/cmd/fossil/flproto - 664 sys sys 1042005508 210
+sys/src/cmd/fossil/flproto - 664 sys sys 1173736837 222
 sys/src/cmd/fossil/fns.h - 664 sys sys 1139667257 3228
 sys/src/cmd/fossil/fossil-acid - 664 sys sys 1139667278 4365
 sys/src/cmd/fossil/fossil.c - 664 sys sys 1077896345 2435
@@ -12653,7 +12655,7 @@ sys/src/cmd/mk/var.c - 664 sys sys 1131289510 530
 sys/src/cmd/mk/varsub.c - 664 sys sys 1131289511 4425
 sys/src/cmd/mk/word.c - 664 sys sys 944961025 2595
 sys/src/cmd/mkdir.c - 664 sys sys 1082593106 1026
-sys/src/cmd/mkfile - 664 sys sys 1142958953 2451
+sys/src/cmd/mkfile - 664 sys sys 1173736967 2618
 sys/src/cmd/mklib - 664 sys sys 1101213349 618
 sys/src/cmd/mkmany - 664 sys sys 1123818681 1304
 sys/src/cmd/mkone - 664 sys sys 1123943673 910
@@ -12665,28 +12667,30 @@ sys/src/cmd/mtime.c - 664 sys sys 1036172302 450
 sys/src/cmd/mug.c - 664 sys sys 1157143847 24888
 sys/src/cmd/mv.c - 664 sys sys 1163029439 4682
 sys/src/cmd/ndb - 20000000775 sys sys 1080135004 0
-sys/src/cmd/ndb/convDNS2M.c - 664 sys sys 1173059857 6856
-sys/src/cmd/ndb/convM2DNS.c - 664 sys sys 1173335487 10645
-sys/src/cmd/ndb/cs.c - 664 sys sys 1163208617 33080
-sys/src/cmd/ndb/csquery.c - 664 sys sys 1173401775 1073
-sys/src/cmd/ndb/dblookup.c - 664 sys sys 1173335538 18207
-sys/src/cmd/ndb/dn.c - 664 sys sys 1173239201 32107
-sys/src/cmd/ndb/dnarea.c - 664 sys sys 1173059947 2517
-sys/src/cmd/ndb/dnnotify.c - 664 sys sys 1173238959 3158
-sys/src/cmd/ndb/dnresolve.c - 664 sys sys 1173401935 22144
-sys/src/cmd/ndb/dns.c - 664 sys sys 1173401831 15957
-sys/src/cmd/ndb/dns.h - 664 sys sys 1173335529 9992
-sys/src/cmd/ndb/dnsdebug.c - 664 sys sys 1173401872 8650
-sys/src/cmd/ndb/dnserver.c - 664 sys sys 1173335425 4431
-sys/src/cmd/ndb/dnsquery.c - 664 sys sys 1173401783 2199
-sys/src/cmd/ndb/dnstcp.c - 664 sys sys 1173401840 7704
-sys/src/cmd/ndb/dnudpserver.c - 664 sys sys 1173335517 5678
-sys/src/cmd/ndb/ipquery.c - 664 sys sys 1124711426 773
+sys/src/cmd/ndb/convDNS2M.c - 664 sys sys 1117253517 6866
+sys/src/cmd/ndb/convM2DNS.c - 664 sys sys 1060612175 7248
+sys/src/cmd/ndb/cs.c - 664 sys sys 1163208159 33080
+sys/src/cmd/ndb/csquery.c - 664 sys sys 1014926159 1062
+sys/src/cmd/ndb/dblookup.c - 664 sys sys 1143749799 18249
+sys/src/cmd/ndb/dn.acid - 664 sys sys 1144950752 20174
+sys/src/cmd/ndb/dn.c - 664 sys sys 1144952448 28763
+sys/src/cmd/ndb/dnarea.c - 664 sys sys 1121972945 2128
+sys/src/cmd/ndb/dnnotify.c - 664 sys sys 1144952457 3066
+sys/src/cmd/ndb/dnresolve.c - 664 sys sys 1166760846 15351
+sys/src/cmd/ndb/dns.c - 664 sys sys 1146746848 15309
+sys/src/cmd/ndb/dns.h - 664 sys sys 1144952221 10171
+sys/src/cmd/ndb/dnsdebug.c - 664 sys sys 1144952322 8492
+sys/src/cmd/ndb/dnserver.c - 664 sys sys 1143648239 3982
+sys/src/cmd/ndb/dnsquery.c - 664 sys sys 1120564707 2198
+sys/src/cmd/ndb/dnstcp.c - 664 sys sys 1144952355 7349
+sys/src/cmd/ndb/dnudpserver.c - 664 sys sys 1144969068 5337
+sys/src/cmd/ndb/ipquery.c - 664 sys sys 1124711423 773
 sys/src/cmd/ndb/mkdb.c - 664 sys sys 957402054 2886
-sys/src/cmd/ndb/mkfile - 664 sys sys 1173059600 1984
+sys/src/cmd/ndb/mkfile - 664 sys sys 1055701930 1877
 sys/src/cmd/ndb/mkhash.c - 664 sys sys 1014926160 2899
 sys/src/cmd/ndb/mkhosts.c - 664 sys sys 957402054 4294
-sys/src/cmd/ndb/query.c - 664 sys sys 1173239042 1137
+sys/src/cmd/ndb/query.c - 664 sys sys 1078782843 1120
+sys/src/cmd/ndb/time.c - 664 sys sys 957402055 321
 sys/src/cmd/netstat.c - 664 sys sys 1128255434 4086
 sys/src/cmd/news.c - 664 sys sys 1014926614 3778
 sys/src/cmd/nfs.c - 664 sys sys 1050068720 31096
@@ -14370,7 +14374,7 @@ sys/src/fs/dev - 20000000775 sys sys 1140168396 0
 sys/src/fs/dev/apc.c - 664 sys sys 1140167918 14910
 sys/src/fs/dev/cw.c - 664 sys sys 1097712558 43252
 sys/src/fs/dev/fworm.c - 664 sys sys 1140167912 1845
-sys/src/fs/dev/juke.c - 664 sys sys 1097578476 22885
+sys/src/fs/dev/juke.c - 664 sys sys 1173736142 22905
 sys/src/fs/dev/mkfile - 664 sys sys 1015109974 132
 sys/src/fs/dev/mworm.c - 664 sys sys 1140167915 4264
 sys/src/fs/dev/wren.c - 664 sys sys 1140167916 2392
@@ -14440,7 +14444,7 @@ sys/src/fs/pc/ethermii.h - 664 sys sys 1140167955 3259
 sys/src/fs/pc/floppy.c - 664 sys sys 1097579636 14022
 sys/src/fs/pc/kbd.c - 664 sys sys 1015110060 6030
 sys/src/fs/pc/l.s - 664 sys sys 1096008336 10838
-sys/src/fs/pc/lock.c - 664 sys sys 1045502910 3591
+sys/src/fs/pc/lock.c - 664 sys sys 1173736177 3672
 sys/src/fs/pc/malloc.c - 664 sys sys 1096789023 2840
 sys/src/fs/pc/mkfile - 664 sys sys 1140167942 426
 sys/src/fs/pc/mmu.c - 664 sys sys 1015110065 8414
@@ -14465,7 +14469,7 @@ sys/src/fs/port/all.h - 664 sys sys 1146798594 1888
 sys/src/fs/port/auth.c - 664 sys sys 1146785221 7606
 sys/src/fs/port/chk.c - 664 sys sys 1097832483 15683
 sys/src/fs/port/clock.c - 664 sys sys 1097580538 4033
-sys/src/fs/port/con.c - 664 sys sys 1146785256 16304
+sys/src/fs/port/con.c - 664 sys sys 1173736129 16296
 sys/src/fs/port/config.c - 664 sys sys 1157944410 20574
 sys/src/fs/port/console.c - 664 sys sys 1101627646 4886
 sys/src/fs/port/data.c - 664 sys sys 1140167986 4510
@@ -14485,7 +14489,7 @@ sys/src/fs/port/print.c - 664 sys sys 1015110022 153
 sys/src/fs/port/proc.c - 664 sys sys 1097580775 5364
 sys/src/fs/port/sd.h - 664 sys sys 1140774087 2305
 sys/src/fs/port/sub.c - 664 sys sys 1151380380 25860
-sys/src/fs/port/time.c - 664 sys sys 1140167998 6222
+sys/src/fs/port/time.c - 664 sys sys 1173736121 6443
 sys/src/fs/port/uidgid.c - 664 sys sys 1097574050 9192
 sys/src/games - 20000000775 sys sys 1128271724 0
 sys/src/games/4s.c - 664 sys sys 1128271724 1285
@@ -14828,7 +14832,7 @@ sys/src/libc/9sys/werrstr.c - 664 sys sys 1014927340 196
 sys/src/libc/9sys/write.c - 664 sys sys 1014927340 110
 sys/src/libc/9sys/writev.c - 664 sys sys 1014927340 577
 sys/src/libc/9syscall - 20000000775 sys sys 1062619381 0
-sys/src/libc/9syscall/mkfile - 664 sys sys 1173374403 2891
+sys/src/libc/9syscall/mkfile - 664 sys sys 1173737379 2800
 sys/src/libc/9syscall/sys.h - 664 sys sys 1143129935 927
 sys/src/libc/alpha - 20000000775 sys sys 1067718982 0
 sys/src/libc/alpha/_seek.c - 664 sys sys 1130424714 180
@@ -15423,7 +15427,7 @@ sys/src/libndb/ndbhash.c - 664 sys sys 1144174490 5276
 sys/src/libndb/ndbhf.h - 664 sys sys 1015013485 746
 sys/src/libndb/ndbipinfo.c - 664 sys sys 1157899101 5127
 sys/src/libndb/ndblookval.c - 664 sys sys 1078839929 791
-sys/src/libndb/ndbopen.c - 664 sys sys 1069206441 2716
+sys/src/libndb/ndbopen.c - 664 sys sys 1173737251 2717
 sys/src/libndb/ndbparse.c - 664 sys sys 1144174490 1207
 sys/src/libndb/ndbreorder.c - 664 sys sys 1078618600 966
 sys/src/libndb/ndbsubstitute.c - 664 sys sys 1144174491 867

dist/replica/plan9.log

@@ -47806,3 +47806,69 @@
 1173414606 0 a sys/src/ape/lib/ap/syscall/genall - 775 sys sys 1173413221 383
 1173414606 1 c sys/src/ape/lib/ap/syscall/mkfile - 664 sys sys 1173413222 351
 1173414606 2 d sys/src/ape/lib/ap/syscall/geninstall - 775 sys sys 1173384418 0
+1173736806 0 c sys/games/lib/fortunes - 664 sys sys 1173736758 264000
+1173736806 1 c sys/lib/dist/mkfile - 664 sys sys 1173736647 5154
+1173736806 2 c sys/src/ape/lib/ap/plan9/kill.c - 664 sys sys 1173736785 912
+1173736806 3 c sys/src/cmd/fossil/check.c - 664 sys sys 1173736846 17436
+1173736806 4 c sys/src/cmd/fossil/flproto - 664 sys sys 1173736837 222
+1173736806 5 c sys/src/fs/dev/juke.c - 664 sys sys 1173736142 22905
+1173736806 6 c sys/src/fs/pc/lock.c - 664 sys sys 1173736177 3672
+1173736806 7 c sys/src/fs/port/con.c - 664 sys sys 1173736129 16296
+1173736806 8 c sys/src/fs/port/time.c - 664 sys sys 1173736121 6443
+1173738606 0 c lib/face/48x48x8/.dict - 664 sys sys 1173737462 3000
+1173738606 1 a lib/face/48x48x8/f/fgb.1 - 664 sys sys 1173737473 2966
+1173738606 2 c lib/vgadb - 664 sys sys 1173737426 30457
+1173738606 3 c rc/bin/fshalt - 775 sys sys 1173737783 1652
+1173738606 4 c rc/bin/label - 775 sys sys 1173737765 189
+1173738606 5 a sys/man/8/fshalt - 664 sys sys 1173737264 862
+1173738606 6 c sys/man/8/listen - 664 sys sys 1173736981 3562
+1173738606 7 c sys/src/ape/lib/ap/syscall/genall - 775 sys sys 1173737406 520
+1173738606 8 c sys/src/ape/lib/ap/syscall/mkfile - 664 sys sys 1173737407 489
+1173738606 9 c sys/src/cmd/aux/listen.c - 664 sys sys 1173736994 8997
+1173738606 10 c sys/src/cmd/ndb/convDNS2M.c - 664 sys sys 1117253517 6866
+1173738606 11 c sys/src/cmd/ndb/convM2DNS.c - 664 sys sys 1060612175 7248
+1173738606 12 c sys/src/cmd/ndb/cs.c - 664 sys sys 1163208159 33080
+1173738606 13 c sys/src/cmd/ndb/csquery.c - 664 sys sys 1014926159 1062
+1173738606 14 c sys/src/cmd/ndb/dblookup.c - 664 sys sys 1143749799 18249
+1173738606 15 a sys/src/cmd/ndb/dn.acid - 664 sys sys 1144950752 20174
+1173738606 16 c sys/src/cmd/ndb/dn.c - 664 sys sys 1144952448 28763
+1173738606 17 c sys/src/cmd/ndb/dnarea.c - 664 sys sys 1121972945 2128
+1173738606 18 c sys/src/cmd/ndb/dnnotify.c - 664 sys sys 1144952457 3066
+1173738606 19 c sys/src/cmd/ndb/dnresolve.c - 664 sys sys 1166760846 15351
+1173738606 20 c sys/src/cmd/ndb/dns.c - 664 sys sys 1146746848 15309
+1173738606 21 c sys/src/cmd/ndb/dns.h - 664 sys sys 1144952221 10171
+1173738606 22 c sys/src/cmd/ndb/dnsdebug.c - 664 sys sys 1144952322 8492
+1173738606 23 c sys/src/cmd/ndb/dnserver.c - 664 sys sys 1143648239 3982
+1173738606 24 c sys/src/cmd/ndb/dnsquery.c - 664 sys sys 1120564707 2198
+1173738606 25 c sys/src/cmd/ndb/dnstcp.c - 664 sys sys 1144952355 7349
+1173738606 26 c sys/src/cmd/ndb/dnudpserver.c - 664 sys sys 1144969068 5337
+1173738606 27 c sys/src/cmd/ndb/ipquery.c - 664 sys sys 1124711423 773
+1173738606 28 c sys/src/cmd/ndb/mkfile - 664 sys sys 1055701930 1877
+1173738606 29 c sys/src/cmd/ndb/query.c - 664 sys sys 1078782843 1120
+1173738606 30 a sys/src/cmd/ndb/time.c - 664 sys sys 957402055 321
+1173738606 31 c sys/src/cmd/mkfile - 664 sys sys 1173736967 2618
+1173738606 32 c sys/src/libc/9syscall/mkfile - 664 sys sys 1173737379 2800
+1173738606 33 c sys/src/libndb/ndbopen.c - 664 sys sys 1173737251 2717
+1173754806 0 c 386/bin/awk - 775 sys sys 1173754554 324980
+1173754806 1 c 386/bin/eqn - 775 sys sys 1173754555 244858
+1173754806 2 c 386/bin/grap - 775 sys sys 1173754557 282722
+1173754806 3 c 386/bin/gs - 775 sys sys 1173754582 13278932
+1173754806 4 c 386/bin/ape/basename - 775 sys sys 1173754547 134719
+1173754806 5 c 386/bin/ape/diff - 775 sys sys 1173754548 352264
+1173754806 6 c 386/bin/ape/diff3 - 775 sys sys 1173754549 190364
+1173754806 7 c 386/bin/ape/dirname - 775 sys sys 1173754549 134498
+1173754806 8 c 386/bin/ape/expr - 775 sys sys 1173754549 144138
+1173754806 9 c 386/bin/ape/kill - 775 sys sys 1173754550 140067
+1173754806 10 c 386/bin/ape/make - 775 sys sys 1173754550 211605
+1173754806 11 c 386/bin/ape/patch - 775 sys sys 1173754551 305848
+1173754806 12 c 386/bin/ape/sed - 775 sys sys 1173754551 160183
+1173754806 13 c 386/bin/ape/sh - 775 sys sys 1173754552 481732
+1173754806 14 c 386/bin/ape/uname - 775 sys sys 1173754552 134895
+1173754806 15 c 386/bin/aux/listen - 775 sys sys 1173754552 108570
+1173754806 16 c 386/bin/aux/lpdaemon - 775 sys sys 1173754553 170710
+1173754806 17 c 386/bin/aux/lpdsend - 775 sys sys 1173754553 157339
+1173754806 18 c 386/bin/compress - 775 sys sys 1173754554 166944
+1173754806 19 c 386/bin/fossil/flchk - 775 sys sys 1173754556 239100
+1173754806 20 c 386/bin/fossil/fossil - 775 sys sys 1173754557 364538
+1173754806 21 c 386/lib/ape/libap.a - 664 sys sys 1173754584 819938
+1173756606 0 c rc/bin/man - 775 sys sys 1173755398 2504

lib/face/48x48x8/.dict

@@ -38,6 +38,7 @@ fi/unknown u/unknown.fi
 flowerbed.dyndns.org/zfolkerts z/zfolkerts.1
 fr/unknown u/unknown.fr
 france3.fr/boyd b/boyd.1
+gmail.com/benavento f/fgb.1
 gmail.com/bruce.ellis b/brucee.1
 gmail.com/ericvh e/ericvh.2
 gmail.com/joelcsalomon c/chesky.1

lib/vgadb

@@ -584,6 +584,7 @@ multisync=1280x1024i
 multisync=1376x1024
 	include=1376x1024
 
+
 #
 # Dell VS17X
 #
@@ -980,6 +981,15 @@ sm753DF=1024x768
 	vrs=769 vre=772 vt=808
 	hsync=+ vsync=+
 
+# Samsung SyncMaster 931BW
+sm931bw=1440x900
+	videobw=130
+	defaultclock=60
+	shb=1520 ehb=1672 ht=1904
+	shs=1520
+	vrs=903 vre=909 vt=934
+	hsync=-	vsync=+
+
 #
 # Sony CPD-1304
 # Horizontal timing:

rc/bin/fshalt

@@ -1,9 +1,21 @@
 #!/bin/rc
-# halt - sync (flush) and, if possible, halt all file servers
+# fshalt [-r] - sync (flush) and, if possible, halt all file servers
+#	and optionally reboot
 rfork e
+reboot=no
+switch ($#*) {
+case 0
+case 1
+	reboot=yes
+case *
+	echo usage: $0 '[-r]' >[1=2]
+	exit usage
+}
+
 path=(/bin)
 builtin cd /
 
+unmount /mnt/consoles >[2]/dev/null
 kill consolefs | rc			# don't compete with /mnt/consoles
 sleep 1
 
@@ -75,7 +87,12 @@ fn x {
 		}
 	}
 	echo
-	echo done
+	echo done halting
+
+	if (~ $reboot yes) {
+		echo rebooting...
+		echo reboot >'#c/reboot'
+	}
 }
 
 x

rc/bin/label

@@ -1,4 +1,6 @@
 #!/bin/rc
 # label word ... - write words into our label, if any
-if (test -e /dev/label)
+if (test -w /dev/label)
 	echo -n $* > /dev/label
+if not if (test -w   /mnt/term/dev/label)
+	echo -n $* > /mnt/term/dev/label

rc/bin/man

@@ -86,7 +86,7 @@ fils=()
 if(~ $search yes)
 for(i in $S/$sec){
 	if(/bin/test -f $i/INDEX){
-		try=`{grep -i $pat $i/INDEX | sed 's/^[^ ]* //'}
+		try=`{grep -i $pat $i/INDEX | sed 's/^[^ ]* //' | sort -u}
 		if(! ~ $#try 0)
 			fils=($fils $i/$try)
 	}

sys/games/lib/fortunes

@@ -4170,3 +4170,5 @@ bool x = "false";  // valid C++ [sets x to true]
 # The below line not be changed otherwise we refuse to work
 having read AF_UNIX(7) i'm still don't see the point.  portable programs should not do this.  portable programs should not do that.  the details of this varies from implementation to implementation.  none of the following socket things ... are implemented.  the name is limited to 107 bytes.   - forsyth
 Please wait. This can take some time.
+I love troff. It reminds me of runoff, which reminds me of my youth, when VMS was in flower and knowledge of EDT and runoff was all a lad needed to make a good living as a tech writer.  - Frank Willison
+General Internet error has occurred. - [OpenOffice.org 2.0]

sys/lib/dist/mkfile

@@ -157,6 +157,7 @@ worldwritable-mail:V:
 9-export:V: 9.tar.gz
 	9fs sources
 	cp 9.tar.gz /n/sources/extra/9.tgz
+	chmod +t    /n/sources/extra/9.tgz
 
 plan9.tar.bz2:V:
 	@{
@@ -176,3 +177,4 @@ plan9.tar.bz2:V:
 plan9-export:V: plan9.tar.bz2
 	9fs sources
 	mv plan9.tar.bz2 /n/sources/extra/plan9.tar.bz2
+	chmod +t	 /n/sources/extra/plan9.tar.bz2

sys/man/8/fshalt

@@ -0,0 +1,48 @@
+.TH FSHALT 8
+.SH NAME
+fshalt, reboot \- halt any local file systems and optionally reboot the system
+.SH SYNOPSIS
+.B fshalt
+[
+.B -r
+]
+.br
+.B reboot
+.SH DESCRIPTION
+.I Fshalt
+syncs all local
+.IR fossil (4),
+.IR venti (8),
+and
+.IR kfs (4)
+servers,
+then halts all local
+.IR fossil
+and
+.IR kfs
+servers.
+If given
+.BR -r ,
+.I fshalt
+will then reboot the machine.
+The halting and rebooting is done by copying all necessary
+commands into a
+.IR ramfs (4)
+file system and changing directory there before attempting to halt
+file systems,
+so this will work even on standalone machines with their roots on
+local file systems.
+.PP
+.I Reboot
+restarts the machine it is invoked on.
+.SH SOURCE
+.B /rc/bin/fshalt
+.br
+.B /rc/bin/reboot
+.SH SEE ALSO
+.IR cons (3),
+.IR reboot (8)
+.SH BUGS
+On standalone machines, it will be impossible to do anything
+after invoking bare
+.LR fshalt .

sys/man/8/listen

@@ -27,7 +27,7 @@ listens on a network for inbound calls to local services.
 .I Net
 is the network protocol on which to listen, by default
 .BR /net/il .
-The services available are executable files in
+The services available are executable, non-empty files in
 .I srvdir
 or
 .IR trustsrvdir .

sys/src/ape/lib/ap/plan9/kill.c

@@ -46,7 +46,7 @@ kill(pid_t pid, int sig)
 	if(pid < 0) {
 		sid = getpgrp();
 		mpid = getpid();
-		if(setpgid(mpid, -pid) > 0) {
+		if(setpgid(mpid, -pid) == 0) {
 			r = note(mpid, msg, "/proc/%d/notepg");
 			setpgid(mpid, sid);
 		} else {

sys/src/ape/lib/ap/syscall/genall

@@ -2,7 +2,9 @@
 # genall - generate the APE versions of the system call C interfaces.
 #	must be invoked by mk so that the right env variables are set.
 rfork e
-SYSH=/sys/src/libc/9syscall/sys.h
+# ugh. sources's build process can't hack absolute path names.
+# we're in /sys/src/ape/lib/ap/syscall.
+SYSH=../../../../libc/9syscall/sys.h	# /sys/src/libc/9syscall/sys.h
 
 SYS=`{sed '/^#define._/d; s/#define.([A-Z0-9_]*).*/\1/' $SYSH}
 for(I in $SYS) {

sys/src/ape/lib/ap/syscall/mkfile

@@ -4,7 +4,9 @@ NPROC=1
 install:V: genall gencall
 	genall
 
-gencall:D: /sys/src/libc/9syscall/mkfile
+# ugh. sources's build process can't hack absolute path names.
+# we're in /sys/src/ape/lib/ap/syscall.
+gencall:D: ../../../../libc/9syscall/mkfile	# /sys/src/libc/9syscall/mkfile
 	{
 		echo '#!/bin/rc'
 		sed -n -e 's/seek/_SEEK/g' -e '/switch/,/\$AS /p' $prereq

sys/src/cmd/aux/listen.c

@@ -353,17 +353,23 @@ dolisten(char *proto, char *dir, int ctl, char *srvdir, char *dialstr)
 }
 
 /*
- * look in the service directory for the service
+ * look in the service directory for the service.
+ * if the shell script or program is zero-length, ignore it,
+ * thus providing a way to disable a service with a bind.
  */
 int 
 findserv(char *proto, char *dir, Service *s, char *srvdir)
 {
+	int rv;
+	Dir *d;
+
 	if(!getserv(proto, dir, s))
 		return 0;
-	sprint(s->prog, "%s/%s", srvdir, s->serv);
-	if(access(s->prog, AEXIST) >= 0)
-		return 1;
-	return 0;
+	snprint(s->prog, sizeof s->prog, "%s/%s", srvdir, s->serv);
+	d = dirstat(s->prog);
+	rv = d && d->length > 0;
+	free(d);
+	return rv;
 }
 
 /*
@@ -396,7 +402,7 @@ getserv(char *proto, char *dir, Service *s)
 	 */
 	if(strlen(serv) +strlen(proto) >= NAMELEN || utfrune(serv, L'/') || *serv == '.')
 		return 0;
-	sprint(s->serv, "%s%s", proto, serv);
+	snprint(s->serv, sizeof s->serv, "%s%s", proto, serv);
 
 	return 1;
 }
@@ -438,7 +444,7 @@ newcall(int fd, char *proto, char *dir, Service *s)
 			syslog(0, listenlog, "%s call for %s on chan %s", proto, s->serv, dir);
 	}
 
-	sprint(data, "%s/data", dir);
+	snprint(data, sizeof data, "%s/data", dir);
 	bind(data, "/dev/cons", MREPL);
 	dup(fd, 0);
 	dup(fd, 1);

sys/src/cmd/fossil/check.c

@@ -2,18 +2,19 @@
 #include "dat.h"
 #include "fns.h"
 
-static void error(Fsck*, char*, ...);
-static void setBit(uchar*, u32int);
-static int getBit(uchar*, u32int);
-static int walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag, u32int epoch);
-static void warn(Fsck*, char*, ...);
-static void checkLeak(Fsck*);
-static void clrenop(Fsck*, Block*, int);
-static void closenop(Fsck*, Block*, u32int);
-static void clrinop(Fsck*, char*, MetaBlock*, int, Block*);
-static int printnop(char*, ...);
-static void checkEpochs(Fsck*);
-static void checkDirs(Fsck*);
+static void	checkDirs(Fsck*);
+static void	checkEpochs(Fsck*);
+static void	checkLeak(Fsck*);
+static void	closenop(Fsck*, Block*, u32int);
+static void	clrenop(Fsck*, Block*, int);
+static void	clrinop(Fsck*, char*, MetaBlock*, int, Block*);
+static void	error(Fsck*, char*, ...);
+static int	getBit(uchar*, u32int);
+static int	printnop(char*, ...);
+static void	setBit(uchar*, u32int);
+static int	walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize],
+			int type, u32int tag, u32int epoch);
+static void	warn(Fsck*, char*, ...);
 
 #pragma varargck argpos error 2
 #pragma varargck argpos warn 2
@@ -41,11 +42,11 @@ checkInit(Fsck *chk)
 }
 
 /*
- * BUG: Should merge checkEpochs and checkDirs so that 
+ * BUG: Should merge checkEpochs and checkDirs so that
  * bad blocks are only reported once, and so that errors in checkEpochs
  * can have the affected file names attached, and so that the file system
  * is only read once.
- * 
+ *
  * Also should summarize the errors instead of printing for every one
  * (e.g., XXX bad or unreachable blocks in /active/usr/rsc/foo).
  */
@@ -90,7 +91,7 @@ checkEpochs(Fsck *chk)
 	chk->xmap = vtMemAllocZ(nb/8+1);
 	chk->errmap = vtMemAllocZ(nb/8+1);
 
-	for(e=chk->fs->ehi; e >= chk->fs->elo; e--){
+	for(e = chk->fs->ehi; e >= chk->fs->elo; e--){
 		memset(chk->emap, 0, chk->nblocks/8+1);
 		memset(chk->xmap, 0, chk->nblocks/8+1);
 		checkEpoch(chk, e);
@@ -109,7 +110,7 @@ checkEpoch(Fsck *chk, u32int epoch)
 	Block *b;
 	Entry e;
 	Label l;
-	
+
 	chk->print("checking epoch %ud...\n", epoch);
 
 	for(a=0; a<chk->nblocks; a++){
@@ -161,10 +162,12 @@ checkEpoch(Fsck *chk, u32int epoch)
  * (ii) if b.e==bb.e,  then no other b' in e points at bb.
  * (iii) if !(b.state&Copied) and b.e==bb.e then no other b' points at bb.
  * (iv) if b is active then no other active b' points at bb.
- * (v) if b is a past life of b' then only one of b and b' is active (too hard to check)
+ * (v) if b is a past life of b' then only one of b and b' is active
+ *	(too hard to check)
  */
 static int
-walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag, u32int epoch)
+walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag,
+	u32int epoch)
 {
 	int i, ret;
 	u32int addr, ep;
@@ -172,7 +175,8 @@ walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag, u
 	Entry e;
 
 	if(b && chk->walkdepth == 0 && chk->printblocks)
-		chk->print("%V %d %#.8ux %#.8ux\n", b->score, b->l.type, b->l.tag, b->l.epoch);
+		chk->print("%V %d %#.8ux %#.8ux\n", b->score, b->l.type,
+			b->l.tag, b->l.epoch);
 
 	if(!chk->useventi && globalToLocal(score) == NilBlock)
 		return 1;
@@ -181,12 +185,14 @@ walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag, u
 
 	bb = cacheGlobal(chk->cache, score, type, tag, OReadOnly);
 	if(bb == nil){
-		error(chk, "could not load block %V type %d tag %ux: %R", score, type, tag);
+		error(chk, "could not load block %V type %d tag %ux: %R",
+			score, type, tag);
 		chk->walkdepth--;
 		return 0;
 	}
 	if(chk->printblocks)
-		chk->print("%*s%V %d %#.8ux %#.8ux\n", chk->walkdepth*2, "", score, type, tag, bb->l.epoch);
+		chk->print("%*s%V %d %#.8ux %#.8ux\n", chk->walkdepth*2, "",
+			score, type, tag, bb->l.epoch);
 
 	ret = 0;
 	addr = globalToLocal(score);
@@ -203,20 +209,22 @@ walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag, u
 				bb->addr, bb->l.epoch, bb->l.epochClose);
 			goto Exit;
 		}
-	
+
 		/* (ii) */
 		if(b->l.epoch == epoch && bb->l.epoch == epoch){
 			if(getBit(chk->emap, addr)){
-				error(chk, "walk: epoch join detected: addr %#ux %L", bb->addr, &bb->l);
+				error(chk, "walk: epoch join detected: addr %#ux %L",
+					bb->addr, &bb->l);
 				goto Exit;
 			}
 			setBit(chk->emap, addr);
 		}
-	
+
 		/* (iii) */
 		if(!(b->l.state&BsCopied) && b->l.epoch == bb->l.epoch){
 			if(getBit(chk->xmap, addr)){
-				error(chk, "walk: copy join detected; addr %#ux %L", bb->addr, &bb->l);
+				error(chk, "walk: copy join detected; addr %#ux %L",
+					bb->addr, &bb->l);
 				goto Exit;
 			}
 			setBit(chk->xmap, addr);
@@ -225,22 +233,26 @@ walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag, u
 
 	/* (iv) */
 	if(epoch == chk->fs->ehi){
-		/* since epoch==fs->ehi is first, amap is same as ``have seen active'' */
+		/*
+		 * since epoch==fs->ehi is first, amap is same as
+		 * ``have seen active''
+		 */
 		if(getBit(chk->amap, addr)){
-			error(chk, "walk: active join detected: addr %#ux %L", bb->addr, &bb->l);
+			error(chk, "walk: active join detected: addr %#ux %L",
+				bb->addr, &bb->l);
 			goto Exit;
 		}
 		if(bb->l.state&BsClosed)
-			error(chk, "walk: addr %#ux: block is in active tree but is closed", addr);
-	}else{
-		if(!getBit(chk->amap, addr)){
+			error(chk, "walk: addr %#ux: block is in active tree but is closed",
+				addr);
+	}else
+		if(!getBit(chk->amap, addr))
 			if(!(bb->l.state&BsClosed)){
-				// error(chk, "walk: addr %#ux: block is not in active tree, not closed (%d)", addr, bb->l.epochClose);
+				// error(chk, "walk: addr %#ux: block is not in active tree, not closed (%d)",
+				// addr, bb->l.epochClose);
 				chk->close(chk, bb, epoch+1);
 				chk->nclose++;
 			}
-		}
-	}
 
 	if(getBit(chk->amap, addr)){
 		ret = 1;
@@ -258,8 +270,9 @@ walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag, u
 	switch(type){
 	default:
 		/* pointer block */
-		for(i=0; i<chk->bsize/VtScoreSize; i++)
-			if(!walkEpoch(chk, bb, bb->data + i*VtScoreSize, type-1, tag, epoch)){
+		for(i = 0; i < chk->bsize/VtScoreSize; i++)
+			if(!walkEpoch(chk, bb, bb->data + i*VtScoreSize,
+			    type-1, tag, epoch)){
 				setBit(chk->errmap, bb->addr);
 				chk->clrp(chk, bb, i);
 				chk->nclrp++;
@@ -268,9 +281,10 @@ walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag, u
 	case BtData:
 		break;
 	case BtDir:
-		for(i=0; i<chk->bsize/VtEntrySize; i++){
+		for(i = 0; i < chk->bsize/VtEntrySize; i++){
 			if(!entryUnpack(&e, bb->data, i)){
-				// error(chk, "walk: could not unpack entry: %ux[%d]: %R", addr, i);
+				// error(chk, "walk: could not unpack entry: %ux[%d]: %R",
+				//	addr, i);
 				setBit(chk->errmap, bb->addr);
 				chk->clre(chk, bb, i);
 				chk->nclre++;
@@ -278,7 +292,8 @@ walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag, u
 			}
 			if(!(e.flags & VtEntryActive))
 				continue;
-//fprint(2, "%x[%d] tag=%x snap=%d score=%V\n", addr, i, e.tag, e.snap, e.score);
+if(0)			fprint(2, "%x[%d] tag=%x snap=%d score=%V\n",
+				addr, i, e.tag, e.snap, e.score);
 			ep = epoch;
 			if(e.snap != 0){
 				if(e.snap >= epoch){
@@ -294,22 +309,24 @@ walkEpoch(Fsck *chk, Block *b, uchar score[VtScoreSize], int type, u32int tag, u
 			if(e.flags & VtEntryLocal){
 				if(e.tag < UserTag)
 				if(e.tag != RootTag || tag != RootTag || i != 1){
-					// error(chk, "bad tag in entry: %ux[%d] tag = %ux", addr, i, e.tag);
+					// error(chk, "bad tag in entry: %ux[%d] tag = %ux",
+					//	addr, i, e.tag);
 					setBit(chk->errmap, bb->addr);
 					chk->clre(chk, bb, i);
 					chk->nclre++;
 					continue;
 				}
-			}else{
+			}else
 				if(e.tag != 0){
-					// error(chk, "bad tag in entry: %ux[%d] tag = %ux", addr, i, e.tag);
+					// error(chk, "bad tag in entry: %ux[%d] tag = %ux",
+					//	addr, i, e.tag);
 					setBit(chk->errmap, bb->addr);
 					chk->clre(chk, bb, i);
 					chk->nclre++;
 					continue;
 				}
-			}
-			if(!walkEpoch(chk, bb, e.score, entryType(&e), e.tag, ep)){
+			if(!walkEpoch(chk, bb, e.score, entryType(&e),
+			    e.tag, ep)){
 				setBit(chk->errmap, bb->addr);
 				chk->clre(chk, bb, i);
 				chk->nclre++;
@@ -333,16 +350,14 @@ Exit:
 static void
 checkLeak(Fsck *chk)
 {
-	u32int a;
-	Label l;
-	u32int nfree;
-	u32int nlost;
+	u32int a, nfree, nlost;
 	Block *b;
+	Label l;
 
 	nfree = 0;
 	nlost = 0;
 
-	for(a=0; a<chk->nblocks; a++){
+	for(a = 0; a < chk->nblocks; a++){
 		if(!readLabel(chk->cache, &l, a)){
 			error(chk, "could not read label: addr %ux %d %d: %R",
 				a, l.type, l.state);
@@ -350,7 +365,8 @@ checkLeak(Fsck *chk)
 		}
 		if(getBit(chk->amap, a))
 			continue;
-		if(l.state == BsFree || l.epochClose <= chk->fs->elo || l.epochClose == l.epoch){
+		if(l.state == BsFree || l.epochClose <= chk->fs->elo ||
+		    l.epochClose == l.epoch){
 			nfree++;
 			setBit(chk->amap, a);
 			continue;
@@ -371,9 +387,9 @@ checkLeak(Fsck *chk)
 		blockPut(b);
 	}
 	chk->print("fsys blocks: total=%ud used=%ud(%.1f%%) free=%ud(%.1f%%) lost=%ud(%.1f%%)\n",
-		chk->nblocks, 
-		chk->nblocks-nfree-nlost, 
-		100.*(chk->nblocks-nfree-nlost)/chk->nblocks,
+		chk->nblocks,
+		chk->nblocks-nfree-nlost,
+		100.*(chk->nblocks - nfree - nlost)/chk->nblocks,
 		nfree, 100.*nfree/chk->nblocks,
 		nlost, 100.*nlost/chk->nblocks);
 }
@@ -383,13 +399,15 @@ checkLeak(Fsck *chk)
  * Check that all sources in the tree are accessible.
  */
 static Source *
-openSource(Fsck *chk, Source *s, char *name, uchar *bm, u32int offset, u32int gen, int dir, MetaBlock *mb, int i, Block *b)
+openSource(Fsck *chk, Source *s, char *name, uchar *bm, u32int offset,
+	u32int gen, int dir, MetaBlock *mb, int i, Block *b)
 {
 	Source *r;
 
 	r = nil;
 	if(getBit(bm, offset)){
-		warn(chk, "multiple references to source: %s -> %d", name, offset);
+		warn(chk, "multiple references to source: %s -> %d",
+			name, offset);
 		goto Err;
 	}
 	setBit(bm, offset);
@@ -419,11 +437,10 @@ Err:
 }
 
 typedef struct MetaChunk MetaChunk;
-
 struct MetaChunk {
-	ushort offset;
-	ushort size;
-	ushort index;
+	ushort	offset;
+	ushort	size;
+	ushort	index;
 };
 
 static int
@@ -452,9 +469,9 @@ chkMetaBlock(MetaBlock *mb)
 
 	mc = vtMemAlloc(mb->nindex*sizeof(MetaChunk));
 	p = mb->buf + MetaHeaderSize;
-	for(i = 0; i<mb->nindex; i++){
-		mc[i].offset = (p[0]<<8) | p[1];
-		mc[i].size = (p[2]<<8) | p[3];
+	for(i = 0; i < mb->nindex; i++){
+		mc[i].offset = p[0]<<8 | p[1];
+		mc[i].size =   p[2]<<8 | p[3];
 		mc[i].index = i;
 		p += MetaIndexSize;
 	}
@@ -465,16 +482,14 @@ chkMetaBlock(MetaBlock *mb)
 	oo = MetaHeaderSize + mb->maxindex*MetaIndexSize;
 	o = oo;
 	n = 0;
-	for(i=0; i<mb->nindex; i++){
+	for(i = 0; i < mb->nindex; i++){
 		o = mc[i].offset;
 		n = mc[i].size;
 		if(o < oo)
 			goto Err;
 		oo += n;
 	}
-	if(o+n > mb->size)
-		goto Err;
-	if(mb->size - oo != mb->free)
+	if(o+n > mb->size || mb->size - oo != mb->free)
 		goto Err;
 
 	vtMemFree(mc);
@@ -485,10 +500,11 @@ if(0){
 	fprint(2, "metaChunks failed!\n");
 	oo = MetaHeaderSize + mb->maxindex*MetaIndexSize;
 	for(i=0; i<mb->nindex; i++){
-		fprint(2, "\t%d: %d %d\n", i, mc[i].offset, mc[i].offset + mc[i].size);
+		fprint(2, "\t%d: %d %d\n", i, mc[i].offset,
+			mc[i].offset + mc[i].size);
 		oo += mc[i].size;
 	}
-	fprint(2, "\tused=%d size=%d free=%d free2=%d\n", 
+	fprint(2, "\tused=%d size=%d free=%d free2=%d\n",
 		oo, mb->size, mb->free, mb->size - oo);
 }
 	vtMemFree(mc);
@@ -498,10 +514,9 @@ if(0){
 static void
 scanSource(Fsck *chk, char *name, Source *r)
 {
-	u32int nb, o;
+	u32int a, nb, o;
 	Block *b;
 	Entry e;
-	u32int a;
 
 	if(!chk->useventi && globalToLocal(r->score)==NilBlock)
 		return;
@@ -517,7 +532,7 @@ scanSource(Fsck *chk, char *name, Source *r)
 	setBit(chk->smap, a);
 
 	nb = (sourceGetSize(r) + r->dsize-1) / r->dsize;
-	for(o=0; o<nb; o++){
+	for(o = 0; o < nb; o++){
 		b = sourceBlock(r, o, OReadOnly);
 		if(b == nil){
 			error(chk, "could not read block in data file %s", name);
@@ -538,19 +553,19 @@ scanSource(Fsck *chk, char *name, Source *r)
 static void
 chkDir(Fsck *chk, char *name, Source *source, Source *meta)
 {
+	int i;
+	u32int a1, a2, nb, o;
+	char *s, *nn;
 	uchar *bm;
 	Block *b, *bb;
-	u32int nb, o;
-	MetaBlock mb;
 	DirEntry de;
 	Entry e1, e2;
+	MetaBlock mb;
 	MetaEntry me;
-	int i;
-	char *s, *nn;
 	Source *r, *mr;
-	u32int a1, a2;
 
-	if(!chk->useventi && globalToLocal(source->score)==NilBlock && globalToLocal(meta->score)==NilBlock)
+	if(!chk->useventi && globalToLocal(source->score)==NilBlock &&
+	    globalToLocal(meta->score)==NilBlock)
 		return;
 
 	if(!sourceLock2(source, meta, OReadOnly)){
@@ -575,19 +590,22 @@ chkDir(Fsck *chk, char *name, Source *source, Source *meta)
 	bm = vtMemAllocZ(sourceGetDirSize(source)/8 + 1);
 
 	nb = (sourceGetSize(meta) + meta->dsize - 1)/meta->dsize;
-	for(o=0; o<nb; o++){
+	for(o = 0; o < nb; o++){
 		b = sourceBlock(meta, o, OReadOnly);
 		if(b == nil){
-			error(chk, "could not read block in meta file: %s[%ud]: %R", name, o);
+			error(chk, "could not read block in meta file: %s[%ud]: %R",
+				name, o);
 			continue;
 		}
-if(0)fprint(2, "source %V:%d block %d addr %d\n", source->score, source->offset, o, b->addr);
+if(0)		fprint(2, "source %V:%d block %d addr %d\n", source->score,
+			source->offset, o, b->addr);
 		if(b->addr != NilBlock && getBit(chk->errmap, b->addr))
 			warn(chk, "previously reported error in block %ux is in %s",
 				b->addr, name);
 
 		if(!mbUnpack(&mb, b->data, meta->dsize)){
-			error(chk, "could not unpack meta block: %s[%ud]: %R", name, o);
+			error(chk, "could not unpack meta block: %s[%ud]: %R",
+				name, o);
 			blockPut(b);
 			continue;
 		}
@@ -600,12 +618,15 @@ if(0)fprint(2, "source %V:%d block %d addr %d\n", source->score, source->offset,
 		for(i=mb.nindex-1; i>=0; i--){
 			meUnpack(&me, &mb, i);
 			if(!deUnpack(&de, &me)){
-				error(chk, "cound not unpack dir entry: %s[%ud][%d]: %R", name, o, i);
+				error(chk,
+				  "could not unpack dir entry: %s[%ud][%d]: %R",
+					name, o, i);
 				continue;
 			}
 			if(s && strcmp(s, de.elem) <= 0)
-				error(chk, "dir entry out of order: %s[%ud][%d] = %s last = %s", name, o, i,
-					de.elem, s);
+				error(chk,
+			   "dir entry out of order: %s[%ud][%d] = %s last = %s",
+					name, o, i, de.elem, s);
 			vtMemFree(s);
 			s = vtStrDup(de.elem);
 			nn = smprint("%s/%s", name, de.elem);
@@ -613,16 +634,15 @@ if(0)fprint(2, "source %V:%d block %d addr %d\n", source->score, source->offset,
 				error(chk, "out of memory");
 				continue;
 			}
-			if(chk->printdirs){
+			if(chk->printdirs)
 				if(de.mode&ModeDir)
 					chk->print("%s/\n", nn);
-			}
-			if(chk->printfiles){
+			if(chk->printfiles)
 				if(!(de.mode&ModeDir))
 					chk->print("%s\n", nn);
-			}
 			if(!(de.mode & ModeDir)){
-				r = openSource(chk, source, nn, bm, de.entry, de.gen, 0, &mb, i, b);
+				r = openSource(chk, source, nn, bm, de.entry,
+					de.gen, 0, &mb, i, b);
 				if(r != nil){
 					if(sourceLock(r, OReadOnly)){
 						scanSource(chk, nn, r);
@@ -635,14 +655,16 @@ if(0)fprint(2, "source %V:%d block %d addr %d\n", source->score, source->offset,
 				continue;
 			}
 
-			r = openSource(chk, source, nn, bm, de.entry, de.gen, 1, &mb, i, b);
+			r = openSource(chk, source, nn, bm, de.entry,
+				de.gen, 1, &mb, i, b);
 			if(r == nil){
 				deCleanup(&de);
 				free(nn);
 				continue;
 			}
 
-			mr = openSource(chk, source, nn, bm, de.mentry, de.mgen, 0, &mb, i, b);
+			mr = openSource(chk, source, nn, bm, de.mentry,
+				de.mgen, 0, &mb, i, b);
 			if(mr == nil){
 				sourceClose(r);
 				deCleanup(&de);
@@ -672,7 +694,8 @@ if(0)fprint(2, "source %V:%d block %d addr %d\n", source->score, source->offset,
 		if(r == nil)
 			continue;
 		warn(chk, "non referenced entry in source %s[%d]", name, o);
-		if((bb = sourceBlock(source, o/(source->dsize/VtEntrySize), OReadOnly)) != nil){
+		if((bb = sourceBlock(source, o/(source->dsize/VtEntrySize),
+		    OReadOnly)) != nil){
 			if(bb->addr != NilBlock){
 				setBit(chk->errmap, bb->addr);
 				chk->clre(chk, bb, o%(source->dsize/VtEntrySize));
@@ -724,12 +747,12 @@ getBit(uchar *bmap, u32int addr)
 static void
 error(Fsck *chk, char *fmt, ...)
 {
-	static nerr;
+	char buf[256];
 	va_list arg;
-	char buf[128];
+	static int nerr;
 
 	va_start(arg, fmt);
-	vseprint(buf, buf+sizeof(buf), fmt, arg);
+	vseprint(buf, buf+sizeof buf, fmt, arg);
 	va_end(arg);
 
 	chk->print("error: %s\n", buf);
@@ -741,13 +764,12 @@ error(Fsck *chk, char *fmt, ...)
 static void
 warn(Fsck *chk, char *fmt, ...)
 {
-	static nerr;
+	char buf[256];
 	va_list arg;
-	char buf[128];
-
+	static int nerr;
 
 	va_start(arg, fmt);
-	vseprint(buf, buf+sizeof(buf), fmt, arg);
+	vseprint(buf, buf+sizeof buf, fmt, arg);
 	va_end(arg);
 
 	chk->print("error: %s\n", buf);

sys/src/cmd/fossil/flproto

@@ -2,7 +2,7 @@
 # Test filesystem.
 #
 fsys main config /tmp/fossil
-fsys main open -AWP
+fsys main open
 fsys main 
 uname rsc :rsc
 uname sys +rsc
@@ -11,3 +11,4 @@ uname sys +jmk
 srv -p test.fscons
 srv test.fossil
 create /active/tmp sys sys d777
+srv -N test.none

sys/src/cmd/mkfile

@@ -15,12 +15,21 @@ NOMK=$NOTSYS|$BUGGERED|$OUTOFDATE
 
 cpuobjtype=`{sed -n 's/^O=//p' /$cputype/mkfile}
 DIRS=`{ls -l | sed '/^d/!d; s/.* //; /^('$NOMK')$/d'}
+APEDIRS=awk bzip2 compress cvs eqn grap gs links-ape lp pic postscript spin \
+	tex troff
 
 none:VQ:
 	echo usage: mk cmds, dirs, all, install, installall, '$O'.cmd, cmd.install, or cmd.installall
 
 cmds:V:	$PROGS
 
+ape:V: $APE
+	for(i in $APEDIRS) @{
+		cd $i
+		echo mk $i
+		mk $MKFLAGS all
+	}
+
 dirs:V:
 	for(i in cc $DIRS) @{
 		cd $i

sys/src/cmd/ndb/convDNS2M.c

@@ -17,10 +17,10 @@ struct Dict
 		ushort	offset;		/* pointer to packed name in message */
 		char	*name;		/* pointer to unpacked name in buf */
 	} x[Ndict];
-	int	n;		/* size of dictionary */
-	uchar	*start;		/* start of packed message */
-	char	buf[4*1024];	/* buffer for unpacked names */
-	char	*ep;		/* first free char in buf */
+	int n;			/* size of dictionary */
+	uchar *start;		/* start of packed message */
+	char buf[4*1024];	/* buffer for unpacked names */
+	char *ep;		/* first free char in buf */
 };
 
 #define NAME(x)		p = pname(p, ep, x, dp)
@@ -129,17 +129,17 @@ pv6addr(uchar *p, uchar *ep, char *name)
 static uchar*
 pname(uchar *p, uchar *ep, char *np, Dict *dp)
 {
-	int i;
 	char *cp;
+	int i;
 	char *last;		/* last component packed */
 
-	if(strlen(np) >= Domlen) /* make sure we don't exceed DNS limits */
+	if(strlen(np) >= Domlen)	/* make sure we don't exceed DNS limits */
 		return ep+1;
 
 	last = 0;
 	while(*np){
 		/* look through every component in the dictionary for a match */
-		for(i = 0; i < dp->n; i++)
+		for(i = 0; i < dp->n; i++){
 			if(strcmp(np, dp->x[i].name) == 0){
 				if(ep - p < 2)
 					return ep+1;
@@ -147,9 +147,10 @@ pname(uchar *p, uchar *ep, char *np, Dict *dp)
 				*p++ = dp->x[i].offset;
 				return p;
 			}
+		}
 
 		/* if there's room, enter this name in dictionary */
-		if(dp->n < Ndict)
+		if(dp->n < Ndict){
 			if(last){
 				/* the whole name is already in dp->buf */
 				last = strchr(last, '.') + 1;
@@ -159,7 +160,7 @@ pname(uchar *p, uchar *ep, char *np, Dict *dp)
 			} else {
 				/* add to dp->buf */
 				i = strlen(np);
-				if(dp->ep + i + 1 < &dp->buf[sizeof dp->buf]){
+				if(dp->ep + i + 1 < &dp->buf[sizeof(dp->buf)]){
 					strcpy(dp->ep, np);
 					dp->x[dp->n].name = dp->ep;
 					last = dp->ep;
@@ -168,10 +169,11 @@ pname(uchar *p, uchar *ep, char *np, Dict *dp)
 					dp->n++;
 				}
 			}
+		}
 
 		/* put next component into message */
 		cp = strchr(np, '.');
-		if(cp == nil){
+		if(cp == 0){
 			i = strlen(np);
 			cp = np + i;	/* point to null terminator */
 		} else {

sys/src/cmd/ndb/convM2DNS.c

@@ -9,91 +9,66 @@ struct Scan
 	uchar	*base;
 	uchar	*p;
 	uchar	*ep;
-
 	char	*err;
-	char	errbuf[256];	/* hold a formatted error sometimes */
-	int	rcode;		/* outgoing response codes (reply flags) */
 };
 
-#define NAME(x)		gname(x, rp, sp)
-#define SYMBOL(x)	(x = gsym(rp, sp))
-#define STRING(x)	(x = gstr(rp, sp))
-#define USHORT(x)	(x = gshort(rp, sp))
-#define ULONG(x)	(x = glong(rp, sp))
-#define UCHAR(x)	(x = gchar(rp, sp))
-#define V4ADDR(x)	(x = gv4addr(rp, sp))
-#define V6ADDR(x)	(x = gv6addr(rp, sp))
-#define BYTES(x, y)	(y = gbytes(rp, sp, &x, len - (sp->p - data)))
-
-static int
-errneg(RR *rp, Scan *sp, int actual)
-{
-	snprint(sp->errbuf, sizeof sp->errbuf, "negative len %d: %R",
-		actual, rp);
-	sp->err = sp->errbuf;
-	return 0;
-}
+#define NAME(x)		gname(x, sp)
+#define SYMBOL(x)	(x = gsym(sp))
+#define STRING(x)	(x = gstr(sp))
+#define USHORT(x)	(x = gshort(sp))
+#define ULONG(x)	(x = glong(sp))
+#define UCHAR(x)	(x = gchar(sp))
+#define V4ADDR(x)	(x = gv4addr(sp))
+#define V6ADDR(x)	(x = gv6addr(sp))
+#define BYTES(x, y)	(y = gbytes(sp, &x, len - (sp->p - data)))
 
-static int
-errtoolong(RR *rp, Scan *sp, int actual, int nominal, char *where)
-{
-	char *p, *ep;
-	char ptype[64];
-
-	p =  sp->errbuf;
-	ep = sp->errbuf + sizeof sp->errbuf - 1;
-	if (where)
-		p = seprint(p, ep, "%s: ", where);
-	if (rp)
-		p = seprint(p, ep, "type %s RR: ",
-			rrname(rp->type, ptype, sizeof ptype));
-	p = seprint(p, ep, "wrong length (actual %d, nominal %d)",
-		actual, nominal);
-	if (rp)
-		seprint(p, ep, ": %R", rp);
-	sp->err = sp->errbuf;
-	return 0;
-}
+static char *toolong = "too long";
 
 /*
  *  get a ushort/ulong
  */
 static ushort
-gchar(RR *rp, Scan *sp)
+gchar(Scan *sp)
 {
 	ushort x;
 
 	if(sp->err)
 		return 0;
-	if(sp->ep - sp->p < 1)
-		return errtoolong(rp, sp, sp->ep - sp->p, 1, "gchar");
+	if(sp->ep - sp->p < 1){
+		sp->err = toolong;
+		return 0;
+	}
 	x = sp->p[0];
 	sp->p += 1;
 	return x;
 }
 static ushort
-gshort(RR *rp, Scan *sp)
+gshort(Scan *sp)
 {
 	ushort x;
 
 	if(sp->err)
 		return 0;
-	if(sp->ep - sp->p < 2)
-		return errtoolong(rp, sp, sp->ep - sp->p, 2, "gshort");
-	x = sp->p[0]<<8 | sp->p[1];
+	if(sp->ep - sp->p < 2){
+		sp->err = toolong;
+		return 0;
+	}
+	x = (sp->p[0]<<8) | sp->p[1];
 	sp->p += 2;
 	return x;
 }
 static ulong
-glong(RR *rp, Scan *sp)
+glong(Scan *sp)
 {
 	ulong x;
 
 	if(sp->err)
 		return 0;
-	if(sp->ep - sp->p < 4)
-		return errtoolong(rp, sp, sp->ep - sp->p, 4, "glong");
-	x = sp->p[0]<<24 | sp->p[1]<<16 | sp->p[2]<<8 | sp->p[3];
+	if(sp->ep - sp->p < 4){
+		sp->err = toolong;
+		return 0;
+	}
+	x = (sp->p[0]<<24) | (sp->p[1]<<16) | (sp->p[2]<<8) | sp->p[3];
 	sp->p += 4;
 	return x;
 }
@@ -102,29 +77,32 @@ glong(RR *rp, Scan *sp)
  *  get an ip address
  */
 static DN*
-gv4addr(RR *rp, Scan *sp)
+gv4addr(Scan *sp)
 {
 	char addr[32];
 
 	if(sp->err)
 		return 0;
-	if(sp->ep - sp->p < 4)
-		return (DN*)errtoolong(rp, sp, sp->ep - sp->p, 4, "gv4addr");
+	if(sp->ep - sp->p < 4){
+		sp->err = toolong;
+		return 0;
+	}
 	snprint(addr, sizeof(addr), "%V", sp->p);
 	sp->p += 4;
 
 	return dnlookup(addr, Cin, 1);
 }
 static DN*
-gv6addr(RR *rp, Scan *sp)
+gv6addr(Scan *sp)
 {
 	char addr[64];
 
 	if(sp->err)
 		return 0;
-	if(sp->ep - sp->p < IPaddrlen)
-		return (DN*)errtoolong(rp, sp, sp->ep - sp->p, IPaddrlen,
-			"gv6addr");
+	if(sp->ep - sp->p < IPaddrlen){
+		sp->err = toolong;
+		return 0;
+	}
 	snprint(addr, sizeof(addr), "%I", sp->p);
 	sp->p += IPaddrlen;
 
@@ -135,27 +113,25 @@ gv6addr(RR *rp, Scan *sp)
  *  get a string.  make it an internal symbol.
  */
 static DN*
-gsym(RR *rp, Scan *sp)
+gsym(Scan *sp)
 {
 	int n;
 	char sym[Strlen+1];
 
 	if(sp->err)
 		return 0;
-	n = 0;
-	if (sp->p < sp->ep)
-		n = *(sp->p++);
-	if(sp->ep - sp->p < n)
-		return (DN*)errtoolong(rp, sp, sp->ep - sp->p, n, "gsym");
+	n = *(sp->p++);
+	if(sp->p+n > sp->ep){
+		sp->err = toolong;
+		return 0;
+	}
 
 	if(n > Strlen){
-		sp->err = "illegal string (symbol)";
+		sp->err = "illegal string";
 		return 0;
 	}
 	strncpy(sym, (char*)sp->p, n);
 	sym[n] = 0;
-	if (strlen(sym) != n)
-		sp->err = "symbol shorter than declared length";
 	sp->p += n;
 
 	return dnlookup(sym, Csym, 1);
@@ -165,7 +141,7 @@ gsym(RR *rp, Scan *sp)
  *  get a string.  don't make it an internal symbol.
  */
 static Txt*
-gstr(RR *rp, Scan *sp)
+gstr(Scan *sp)
 {
 	int n;
 	char sym[Strlen+1];
@@ -173,11 +149,11 @@ gstr(RR *rp, Scan *sp)
 
 	if(sp->err)
 		return 0;
-	n = 0;
-	if (sp->p < sp->ep)
-		n = *(sp->p++);
-	if(sp->ep - sp->p < n)
-		return (Txt*)errtoolong(rp, sp, sp->ep - sp->p, n, "gstr");
+	n = *(sp->p++);
+	if(sp->p+n > sp->ep){
+		sp->err = toolong;
+		return 0;
+	}
 
 	if(n > Strlen){
 		sp->err = "illegal string";
@@ -185,8 +161,6 @@ gstr(RR *rp, Scan *sp)
 	}
 	strncpy(sym, (char*)sp->p, n);
 	sym[n] = 0;
-	if (strlen(sym) != n)
-		sp->err = "string shorter than declared length";
 	sp->p += n;
 
 	t = emalloc(sizeof(*t));
@@ -199,15 +173,14 @@ gstr(RR *rp, Scan *sp)
  *  get a sequence of bytes
  */
 static int
-gbytes(RR *rp, Scan *sp, uchar **p, int n)
+gbytes(Scan *sp, uchar **p, int n)
 {
-	*p = nil;			/* i think this is a good idea */
 	if(sp->err)
 		return 0;
-	if(n < 0)
-		return errneg(rp, sp, n);
-	if(sp->ep - sp->p < n)
-		return errtoolong(rp, sp, sp->ep - sp->p, n, "gbytes");
+	if(sp->p+n > sp->ep || n < 0){
+		sp->err = toolong;
+		return 0;
+	}
 	*p = emalloc(n);
 	memmove(*p, sp->p, n);
 	sp->p += n;
@@ -219,10 +192,13 @@ gbytes(RR *rp, Scan *sp, uchar **p, int n)
  *  get a domain name.  'to' must point to a buffer at least Domlen+1 long.
  */
 static char*
-gname(char *to, RR *rp, Scan *sp)
+gname(char *to, Scan *sp)
 {
-	int len, off, pointer, n;
-	char *tostart, *toend;
+	int len, off;
+	int pointer;
+	int n;
+	char *tostart;
+	char *toend;
 	uchar *p;
 
 	tostart = to;
@@ -231,14 +207,14 @@ gname(char *to, RR *rp, Scan *sp)
 	pointer = 0;
 	p = sp->p;
 	toend = to + Domlen;
-	for(len = 0; *p && p < sp->ep; len += pointer ? 0 : (n+1)){
+	for(len = 0; *p; len += pointer ? 0 : (n+1)){
 		if((*p & 0xc0) == 0xc0){
 			/* pointer to other spot in message */
 			if(pointer++ > 10){
 				sp->err = "pointer loop";
 				goto err;
 			}
-			off = (p[0]<<8 | p[1]) & 0x3ff;
+			off = ((p[0]<<8) + p[1]) & 0x3ff;
 			p = sp->base + off;
 			if(p >= sp->ep){
 				sp->err = "bad pointer";
@@ -247,12 +223,10 @@ gname(char *to, RR *rp, Scan *sp)
 			n = 0;
 			continue;
 		}
-		n = 0;
-		if (p < sp->ep)
-			n = *p++;
+		n = *p++;
 		if(len + n < Domlen - 1){
-			if(n > toend - to){
-				errtoolong(rp, sp, toend - to, n, "gname 1");
+			if(to + n > toend){
+				sp->err = toolong;
 				goto err;
 			}
 			memmove(to, p, n);
@@ -261,8 +235,7 @@ gname(char *to, RR *rp, Scan *sp)
 		p += n;
 		if(*p){
 			if(to >= toend){
-				errtoolong(rp, sp, to-tostart, toend-tostart,
-					"gname 2");
+				sp->err = toolong;
 				goto err;
 			}
 			*to++ = '.';
@@ -279,31 +252,17 @@ err:
 	return tostart;
 }
 
-/*
- * ms windows 2000 seems to get the bytes backward in the type field
- * of ptr records, so return a format error as feedback.
- */
-static void
-mstypehack(Scan *sp, int type, char *where)
-{
-	if ((uchar)type == 0 && (uchar)(type>>8) != 0) {
-		syslog(0, "dns",
-			"%s: byte-swapped type field in ptr rr from win2k",
-			where);
-		if (sp->rcode == 0)
-			sp->rcode = Rformat;
-	}
-}
-
 /*
  *  convert the next RR from a message
  */
 static RR*
-convM2RR(Scan *sp, char *what)
+convM2RR(Scan *sp)
 {
-	RR *rp = nil;
-	int type, class, len;
+	RR *rp;
+	int type;
+	int class;
 	uchar *data;
+	int len;
 	char dname[Domlen+1];
 	Txt *t, **l;
 
@@ -312,7 +271,6 @@ retry:
 	USHORT(type);
 	USHORT(class);
 
-	mstypehack(sp, type, "convM2RR");
 	rp = rralloc(type);
 	rp->owner = dnlookup(dname, class, 1);
 	rp->type = type;
@@ -322,20 +280,9 @@ retry:
 	USHORT(len);
 	data = sp->p;
 
-	/*
-	 * ms windows generates a lot of badly-formatted hints.
-	 * hints are only advisory, so don't log complaints about them.
-	 * it also generates answers in which p overshoots ep by exactly
-	 * one byte; this seems to be harmless, so don't log them either.
-	 */
-	if (sp->ep - sp->p < len &&
-	   !(strcmp(what, "hints") == 0 ||
-	     sp->p == sp->ep + 1 && strcmp(what, "answers") == 0)) {
-		syslog(0, "dns", "%s sp: base %#p p %#p ep %#p len %d", what,
-			sp->base, sp->p, sp->ep, len);	/* DEBUG */
-		errtoolong(rp, sp, sp->ep - sp->p, len, "convM2RR");
-	}
-	if(sp->err || sp->rcode){
+	if(sp->p + len > sp->ep)
+		sp->err = toolong;
+	if(sp->err){
 		rrfree(rp);
 		return 0;
 	}
@@ -345,7 +292,6 @@ retry:
 		/* unknown type, just ignore it */
 		sp->p = data + len;
 		rrfree(rp);
-		rp = nil;
 		goto retry;
 	case Thinfo:
 		SYMBOL(rp->cpu);
@@ -360,11 +306,11 @@ retry:
 		break;
 	case Tmg:
 	case Tmr:
-		rp->mb  = dnlookup(NAME(dname), Cin, 1);
+		rp->mb = dnlookup(NAME(dname), Cin, 1);
 		break;
 	case Tminfo:
 		rp->rmb = dnlookup(NAME(dname), Cin, 1);
-		rp->mb  = dnlookup(NAME(dname), Cin, 1);
+		rp->mb = dnlookup(NAME(dname), Cin, 1);
 		break;
 	case Tmx:
 		USHORT(rp->pref);
@@ -381,7 +327,7 @@ retry:
 		break;
 	case Tsoa:
 		rp->host = dnlookup(NAME(dname), Cin, 1);
-		rp->rmb  = dnlookup(NAME(dname), Cin, 1);
+		rp->rmb = dnlookup(NAME(dname), Cin, 1);
 		ULONG(rp->soa->serial);
 		ULONG(rp->soa->refresh);
 		ULONG(rp->soa->retry);
@@ -391,7 +337,7 @@ retry:
 	case Ttxt:
 		l = &rp->txt;
 		*l = nil;
-		while(sp->p - data < len){
+		while(sp->p-data < len){
 			STRING(t);
 			*l = t;
 			l = &t->next;
@@ -402,7 +348,7 @@ retry:
 		break;
 	case Trp:
 		rp->rmb = dnlookup(NAME(dname), Cin, 1);
-		rp->rp  = dnlookup(NAME(dname), Cin, 1);
+		rp->rp = dnlookup(NAME(dname), Cin, 1);
 		break;
 	case Tkey:
 		USHORT(rp->key->flags);
@@ -428,26 +374,8 @@ retry:
 		BYTES(rp->cert->data, rp->cert->dlen);
 		break;
 	}
-	if(sp->p - data != len) {
-		char ptype[64];
-
-		/*
-		 * ms windows 2000 generates cname queries for reverse lookups
-		 * with this particular error.  don't bother logging it.
-		 *
-		 * server: input error: bad cname RR len (actual 2 != len 0):
-		 * 235.9.104.135.in-addr.arpa cname
-		 *	235.9.104.135.in-addr.arpa from 135.104.9.235
-		 */
-		if (type == Tcname && sp->p - data == 2 && len == 0)
-			return rp;
-
-		snprint(sp->errbuf, sizeof sp->errbuf,
-			"bad %s RR len (actual %lud != len %d): %R",
-			rrname(type, ptype, sizeof ptype),
-			sp->p - data, len, rp);
-		sp->err = sp->errbuf;
-	}
+	if(sp->p - data != len)
+		sp->err = "bad RR len";
 	return rp;
 }
 
@@ -458,16 +386,16 @@ static RR*
 convM2Q(Scan *sp)
 {
 	char dname[Domlen+1];
-	int type, class;
-	RR *rp = nil;
+	int type;
+	int class;
+	RR *rp;
 
 	NAME(dname);
 	USHORT(type);
 	USHORT(class);
-	if(sp->err || sp->rcode)
+	if(sp->err)
 		return 0;
 
-	mstypehack(sp, type, "convM2Q");
 	rp = rralloc(type);
 	rp->owner = dnlookup(dname, class, 1);
 
@@ -475,20 +403,21 @@ convM2Q(Scan *sp)
 }
 
 static RR*
-rrloop(Scan *sp, char *what, int count, int quest)
+rrloop(Scan *sp, int count, int quest)
 {
 	int i;
+	static char errbuf[64];
 	RR *first, *rp, **l;
 
-	if(sp->err || sp->rcode)
+	if(sp->err)
 		return 0;
 	l = &first;
 	first = 0;
 	for(i = 0; i < count; i++){
-		rp = quest ? convM2Q(sp) : convM2RR(sp, what);
-		if(rp == nil)
+		rp = quest ? convM2Q(sp) : convM2RR(sp);
+		if(rp == 0)
 			break;
-		if(sp->err || sp->rcode){
+		if(sp->err){
 			rrfree(rp);
 			break;
 		}
@@ -499,44 +428,31 @@ rrloop(Scan *sp, char *what, int count, int quest)
 }
 
 /*
- *  convert the next DNS from a message stream.
- *  if there are formatting errors or the like during parsing of the message,
- *  set *codep to the outgoing response code (e.g., Rformat), which will
- *  abort processing and reply immediately with the outgoing response code.
+ *  convert the next DNS from a message stream
  */
 char*
-convM2DNS(uchar *buf, int len, DNSmsg *m, int *codep)
+convM2DNS(uchar *buf, int len, DNSmsg *m)
 {
 	Scan scan;
 	Scan *sp;
 	char *err;
-	RR *rp = nil;
 
-	if (codep)
-		*codep = 0;
-	assert(len >= 0);
 	scan.base = buf;
 	scan.p = buf;
 	scan.ep = buf + len;
-	scan.err = nil;
-	scan.errbuf[0] = '\0';
-	scan.rcode = 0;
+	scan.err = 0;
 	sp = &scan;
-
-	memset(m, 0, sizeof *m);
+	memset(m, 0, sizeof(DNSmsg));
 	USHORT(m->id);
 	USHORT(m->flags);
 	USHORT(m->qdcount);
 	USHORT(m->ancount);
 	USHORT(m->nscount);
 	USHORT(m->arcount);
-
-	m->qd = rrloop(sp, "questions",	m->qdcount, 1);
-	m->an = rrloop(sp, "answers",	m->ancount, 0);
-	m->ns = rrloop(sp, "nameservers",m->nscount, 0);
+	m->qd = rrloop(sp, m->qdcount, 1);
+	m->an = rrloop(sp, m->ancount, 0);
+	m->ns = rrloop(sp, m->nscount, 0);
 	err = scan.err;				/* live with bad ar's */
-	m->ar = rrloop(sp, "hints",	m->arcount, 0);
-	if (codep)
-		*codep = scan.rcode;
+	m->ar = rrloop(sp, m->arcount, 0);
 	return err;
 }

sys/src/cmd/ndb/csquery.c

@@ -22,7 +22,7 @@ query(char *addr)
 	fd = open(server, ORDWR);
 	if(fd < 0)
 		sysfatal("cannot open %s: %r", server);
-	if(write(fd, addr, strlen(addr)) != strlen(addr)){
+	if(write(fd, addr, strlen(addr)) <= 0){
 		if(!statusonly)
 			fprint(2, "translating %s: %r\n", addr);
 		status = "errors";

sys/src/cmd/ndb/dblookup.c

@@ -68,17 +68,16 @@ opendatabase(void)
  *  shared state there.
  *
  *  e.g. for x.research.bell-labs.com, first look for a match against
- *       the x.research.bell-labs.com.  If nothing matches,
- *	 try *.research.bell-labs.com.
+ *       the x.research.bell-labs.com.  If nothing matches, try *.research.bell-labs.com.
  */
 RR*
 dblookup(char *name, int class, int type, int auth, int ttl)
 {
-	int err;
-	char *wild, *cp;
-	char buf[256];
 	RR *rp, *tp;
+	char buf[256];
+	char *wild, *cp;
 	DN *dp, *ndp;
+	int err;
 	static int parallel;
 	static int parfd[2];
 	static char token[1];
@@ -138,14 +137,14 @@ dblookup(char *name, int class, int type, int auth, int ttl)
 	}
 out:
 	/* add owner to uncached records */
-	if(rp)
+	if(rp){
 		for(tp = rp; tp; tp = tp->next)
 			tp->owner = dp;
-	else {
-		/* don't call it non-existent (etc.) if it's not ours */
+	} else {
+		/* don't call it non-existent if it's not ours */
 		if(err == Rname && !inmyarea(name))
 			err = Rserver;
-		dp->respcode = err;
+		dp->nonexistent = err;
 	}
 
 	unlock(&dblock);
@@ -463,13 +462,13 @@ soarr(Ndbtuple *entry, Ndbtuple *pair)
 		rp->rmb = dnlookup(mailbox, Cin, 1);
 	}
 
-	/*  hang dns slaves off of the soa.  this is
+	/*  hang dns slaves off of the soa.  this is 
 	 *  for managing the area.
 	 */
 	for(t = entry; t != nil; t = t->entry)
 		if(strcmp(t->attr, "dnsslave") == 0)
 			addserver(&rp->soa->slaves, t->val);
-
+			
 	return rp;
 }
 
@@ -528,8 +527,9 @@ dbfile2area(Ndb *db)
 	if(debug)
 		syslog(0, logfile, "rereading %s", db->file);
 	Bseek(&db->b, 0, 0);
-	while(t = ndbparse(db))
+	while(t = ndbparse(db)){
 		ndbfree(t);
+	}
 }
 
 /*
@@ -546,20 +546,22 @@ dbpair2cache(DN *dp, Ndbtuple *entry, Ndbtuple *pair)
 	if(cistrcmp(pair->attr, "ip") == 0){
 		dp->ordinal = ord++;
 		rp = addrrr(entry, pair);
-	} else 	if(cistrcmp(pair->attr, "ns") == 0)
+	} else 	if(cistrcmp(pair->attr, "ns") == 0){
 		rp = nsrr(entry, pair);
-	else if(cistrcmp(pair->attr, "soa") == 0) {
+	} else if(cistrcmp(pair->attr, "soa") == 0){
 		rp = soarr(entry, pair);
 		addarea(dp, rp, pair);
-	} else if(cistrcmp(pair->attr, "mx") == 0)
+	} else if(cistrcmp(pair->attr, "mx") == 0){
 		rp = mxrr(entry, pair);
-	else if(cistrcmp(pair->attr, "cname") == 0)
+	} else if(cistrcmp(pair->attr, "cname") == 0){
 		rp = cnamerr(entry, pair);
-	else if(cistrcmp(pair->attr, "nullrr") == 0)
+	} else if(cistrcmp(pair->attr, "nullrr") == 0){
 		rp = nullrr(entry, pair);
-	else if(cistrcmp(pair->attr, "txtrr") == 0)
+	} else if(cistrcmp(pair->attr, "txtrr") == 0){
 		rp = txtrr(entry, pair);
-	if(rp == nil)
+	}
+
+	if(rp == 0)
 		return;
 
 	rp->owner = dp;
@@ -610,10 +612,11 @@ dbfile2cache(Ndb *db)
 void
 db2cache(int doit)
 {
-	ulong youngest, temp;
 	Ndb *ndb;
 	Dir *d;
-	static ulong lastcheck, lastyoungest;
+	ulong youngest, temp;
+	static ulong lastcheck;
+	static ulong lastyoungest;
 
 	/* no faster than once every 2 minutes */
 	if(now < lastcheck + 2*Min && !doit)
@@ -638,22 +641,23 @@ db2cache(int doit)
 	for(;;){
 		lastcheck = now;
 		youngest = 0;
-		for(ndb = db; ndb; ndb = ndb->next)
-			/* dirfstat avoids walking the mount table each time */
+		for(ndb = db; ndb; ndb = ndb->next){
+			/* the dirfstat avoids walking the mount table each time */
 			if((d = dirfstat(Bfildes(&ndb->b))) != nil ||
 			   (d = dirstat(ndb->file)) != nil){
-				temp = d->mtime;	/* ulong vs int crap */
+				temp = d->mtime;		/* ulong vs int crap */
 				if(temp > youngest)
 					youngest = temp;
 				free(d);
 			}
+		}
 		if(!doit && youngest == lastyoungest)
 			break;
-
+	
 		/* forget our area definition */
 		freearea(&owned);
 		freearea(&delegated);
-
+	
 		/* reopen all the files (to get oldest for time stamp) */
 		for(ndb = db; ndb; ndb = ndb->next)
 			ndbreopen(ndb);
@@ -661,20 +665,21 @@ db2cache(int doit)
 		if(cachedb){
 			/* mark all db records as timed out */
 			dnagedb();
-
+	
 			/* read in new entries */
 			for(ndb = db; ndb; ndb = ndb->next)
 				dbfile2cache(ndb);
-
+	
 			/* mark as authentic anything in our domain */
 			dnauthdb();
-
+	
 			/* remove old entries */
 			dnageall(1);
-		} else
+		} else {
 			/* read all the soa's to get database defaults */
 			for(ndb = db; ndb; ndb = ndb->next)
 				dbfile2area(ndb);
+		}
 
 		doit = 0;
 		lastyoungest = youngest;
@@ -698,7 +703,7 @@ lookupinfo(char *attr)
 
 	snprint(buf, sizeof buf, "%I", ipaddr);
 	a[0] = attr;
-
+	
 	lock(&dblock);
 	if(opendatabase() < 0){
 		unlock(&dblock);
@@ -709,7 +714,7 @@ lookupinfo(char *attr)
 	return t;
 }
 
-char *localservers =	  "local#dns#servers";
+char *localservers = "local#dns#servers";
 char *localserverprefix = "local#dns#server";
 
 /*
@@ -735,8 +740,7 @@ baddelegation(RR *rp, RR *nsrp, uchar *addr)
 		if(rp->owner != nsrp->owner)
 		if(subsume(rp->owner->name, nsrp->owner->name) &&
 		   strcmp(nsrp->owner->name, localservers) != 0){
-			syslog(0, logfile, "delegation loop %R -> %R from %I",
-				nsrp, rp, addr);
+			syslog(0, logfile, "delegation loop %R -> %R from %I", nsrp, rp, addr);
 			return 1;
 		}
 
@@ -745,8 +749,7 @@ baddelegation(RR *rp, RR *nsrp, uchar *addr)
 			if(rp->host && cistrcmp(rp->host->name, nt->val) == 0)
 				break;
 		if(nt != nil && !inmyarea(rp->owner->name)){
-			syslog(0, logfile, "bad delegation %R from %I",
-				rp, addr);
+			syslog(0, logfile, "bad delegation %R from %I", rp, addr);
 			return 1;
 		}
 	}
@@ -789,12 +792,12 @@ addlocaldnsserver(DN *dp, int class, char *ipaddr, int i)
 RR*
 dnsservers(int class)
 {
-	int i, n;
-	char *p, *buf;
-	char *args[5];
 	Ndbtuple *t, *nt;
 	RR *nsrp;
 	DN *dp;
+	char *p;
+	int i, n;
+	char *buf, *args[5];
 
 	dp = dnlookup(localservers, class, 1);
 	nsrp = rrlookup(dp, Tns, NOneg);
@@ -877,10 +880,12 @@ static void
 createptrs(void)
 {
 	int len, dlen, n;
-	char buf[Domlen+1], ipa[48];
-	char *f[40];
-	uchar net[IPaddrlen], mask[IPaddrlen];
 	Area *s;
+	char *f[40];
+	char buf[Domlen+1];
+	uchar net[IPaddrlen];
+	uchar mask[IPaddrlen];
+	char ipa[48];
 	Ndbtuple *t, *nt;
 
 	dlen = strlen(v4ptrdom);
@@ -923,10 +928,10 @@ createptrs(void)
 			net[IPv4off+3] = atoi(f[0]);
 			sprint(ipa, "%I", net);
 			t = ndbipinfo(db, "ip", ipa, attribs, 1);
-			if(t == nil)	/* could be a reverse with no forward */
+			if(t == nil) /* could be a reverse with no forward */
 				continue;
 			nt = look(t, t, "ipmask");
-			if(nt == nil){		/* we're confused */
+			if(nt == nil){	/* we're confused */
 				ndbfree(t);
 				continue;
 			}
@@ -937,10 +942,7 @@ createptrs(void)
 			continue;
 		}
 
-		/*
-		 * go through all domain entries looking for RR's
-		 * in this network and create ptrs
-		 */
+		/* go through all domain entries looking for RR's in this network and create ptrs */
 		dnptr(net, mask, s->soarr->owner->name, 6-n, 0);
 	}
 }

sys/src/cmd/ndb/dn.acid

@@ -0,0 +1,1142 @@
+sizeof_1_ = 8;
+aggr _1_
+{
+	'U' 0 lo;
+	'U' 4 hi;
+};
+
+defn
+_1_(addr) {
+	complex _1_ addr;
+	print("	lo	", addr.lo, "\n");
+	print("	hi	", addr.hi, "\n");
+};
+
+sizeofFPdbleword = 8;
+aggr FPdbleword
+{
+	'F' 0 x;
+	{
+	'U' 0 lo;
+	'U' 4 hi;
+	};
+};
+
+defn
+FPdbleword(addr) {
+	complex FPdbleword addr;
+	print("	x	", addr.x, "\n");
+	print("_1_ {\n");
+		_1_(addr+0);
+	print("}\n");
+};
+
+UTFmax = 3;
+Runesync = 128;
+Runeself = 128;
+Runeerror = 65533;
+sizeofFmt = 48;
+aggr Fmt
+{
+	'b' 0 runes;
+	'X' 4 start;
+	'X' 8 to;
+	'X' 12 stop;
+	'X' 16 flush;
+	'X' 20 farg;
+	'D' 24 nfmt;
+	'X' 28 args;
+	'D' 32 r;
+	'D' 36 width;
+	'D' 40 prec;
+	'U' 44 flags;
+};
+
+defn
+Fmt(addr) {
+	complex Fmt addr;
+	print("	runes	", addr.runes, "\n");
+	print("	start	", addr.start\X, "\n");
+	print("	to	", addr.to\X, "\n");
+	print("	stop	", addr.stop\X, "\n");
+	print("	flush	", addr.flush\X, "\n");
+	print("	farg	", addr.farg\X, "\n");
+	print("	nfmt	", addr.nfmt, "\n");
+	print("	args	", addr.args\X, "\n");
+	print("	r	", addr.r, "\n");
+	print("	width	", addr.width, "\n");
+	print("	prec	", addr.prec, "\n");
+	print("	flags	", addr.flags, "\n");
+};
+
+FmtWidth = 1;
+FmtLeft = 2;
+FmtPrec = 4;
+FmtSharp = 8;
+FmtSpace = 16;
+FmtSign = 32;
+FmtZero = 64;
+FmtUnsigned = 128;
+FmtShort = 256;
+FmtLong = 512;
+FmtVLong = 1024;
+FmtComma = 2048;
+FmtByte = 4096;
+FmtFlag = 8192;
+sizeofTm = 40;
+aggr Tm
+{
+	'D' 0 sec;
+	'D' 4 min;
+	'D' 8 hour;
+	'D' 12 mday;
+	'D' 16 mon;
+	'D' 20 year;
+	'D' 24 wday;
+	'D' 28 yday;
+	'a' 32 zone;
+	'D' 36 tzoff;
+};
+
+defn
+Tm(addr) {
+	complex Tm addr;
+	print("	sec	", addr.sec, "\n");
+	print("	min	", addr.min, "\n");
+	print("	hour	", addr.hour, "\n");
+	print("	mday	", addr.mday, "\n");
+	print("	mon	", addr.mon, "\n");
+	print("	year	", addr.year, "\n");
+	print("	wday	", addr.wday, "\n");
+	print("	yday	", addr.yday, "\n");
+	print("	zone	", addr.zone, "\n");
+	print("	tzoff	", addr.tzoff, "\n");
+};
+
+PNPROC = 1;
+PNGROUP = 2;
+Profoff = 0;
+Profuser = 1;
+Profkernel = 2;
+Proftime = 3;
+Profsample = 4;
+sizeofLock = 4;
+aggr Lock
+{
+	'D' 0 val;
+};
+
+defn
+Lock(addr) {
+	complex Lock addr;
+	print("	val	", addr.val, "\n");
+};
+
+sizeofQLp = 12;
+aggr QLp
+{
+	'D' 0 inuse;
+	'A' QLp 4 next;
+	'C' 8 state;
+};
+
+defn
+QLp(addr) {
+	complex QLp addr;
+	print("	inuse	", addr.inuse, "\n");
+	print("	next	", addr.next\X, "\n");
+	print("	state	", addr.state, "\n");
+};
+
+sizeofQLock = 16;
+aggr QLock
+{
+	Lock 0 lock;
+	'D' 4 locked;
+	'A' QLp 8 $head;
+	'A' QLp 12 $tail;
+};
+
+defn
+QLock(addr) {
+	complex QLock addr;
+	print("Lock lock {\n");
+	Lock(addr.lock);
+	print("}\n");
+	print("	locked	", addr.locked, "\n");
+	print("	$head	", addr.$head\X, "\n");
+	print("	$tail	", addr.$tail\X, "\n");
+};
+
+sizeofRWLock = 20;
+aggr RWLock
+{
+	Lock 0 lock;
+	'D' 4 readers;
+	'D' 8 writer;
+	'A' QLp 12 $head;
+	'A' QLp 16 $tail;
+};
+
+defn
+RWLock(addr) {
+	complex RWLock addr;
+	print("Lock lock {\n");
+	Lock(addr.lock);
+	print("}\n");
+	print("	readers	", addr.readers, "\n");
+	print("	writer	", addr.writer, "\n");
+	print("	$head	", addr.$head\X, "\n");
+	print("	$tail	", addr.$tail\X, "\n");
+};
+
+sizeofRendez = 12;
+aggr Rendez
+{
+	'A' QLock 0 l;
+	'A' QLp 4 $head;
+	'A' QLp 8 $tail;
+};
+
+defn
+Rendez(addr) {
+	complex Rendez addr;
+	print("	l	", addr.l\X, "\n");
+	print("	$head	", addr.$head\X, "\n");
+	print("	$tail	", addr.$tail\X, "\n");
+};
+
+sizeofNetConnInfo = 36;
+aggr NetConnInfo
+{
+	'X' 0 dir;
+	'X' 4 root;
+	'X' 8 spec;
+	'X' 12 lsys;
+	'X' 16 lserv;
+	'X' 20 rsys;
+	'X' 24 rserv;
+	'X' 28 laddr;
+	'X' 32 raddr;
+};
+
+defn
+NetConnInfo(addr) {
+	complex NetConnInfo addr;
+	print("	dir	", addr.dir\X, "\n");
+	print("	root	", addr.root\X, "\n");
+	print("	spec	", addr.spec\X, "\n");
+	print("	lsys	", addr.lsys\X, "\n");
+	print("	lserv	", addr.lserv\X, "\n");
+	print("	rsys	", addr.rsys\X, "\n");
+	print("	rserv	", addr.rserv\X, "\n");
+	print("	laddr	", addr.laddr\X, "\n");
+	print("	raddr	", addr.raddr\X, "\n");
+};
+
+RFNAMEG = 1;
+RFENVG = 2;
+RFFDG = 4;
+RFNOTEG = 8;
+RFPROC = 16;
+RFMEM = 32;
+RFNOWAIT = 64;
+RFCNAMEG = 1024;
+RFCENVG = 2048;
+RFCFDG = 4096;
+RFREND = 8192;
+RFNOMNT = 16384;
+sizeofQid = 16;
+aggr Qid
+{
+	'W' 0 path;
+	'U' 8 vers;
+	'b' 12 type;
+};
+
+defn
+Qid(addr) {
+	complex Qid addr;
+	print("	path	", addr.path, "\n");
+	print("	vers	", addr.vers, "\n");
+	print("	type	", addr.type, "\n");
+};
+
+sizeofDir = 60;
+aggr Dir
+{
+	'u' 0 type;
+	'U' 4 dev;
+	Qid 8 qid;
+	'U' 24 mode;
+	'U' 28 atime;
+	'U' 32 mtime;
+	'V' 36 length;
+	'X' 44 name;
+	'X' 48 uid;
+	'X' 52 gid;
+	'X' 56 muid;
+};
+
+defn
+Dir(addr) {
+	complex Dir addr;
+	print("	type	", addr.type, "\n");
+	print("	dev	", addr.dev, "\n");
+	print("Qid qid {\n");
+	Qid(addr.qid);
+	print("}\n");
+	print("	mode	", addr.mode, "\n");
+	print("	atime	", addr.atime, "\n");
+	print("	mtime	", addr.mtime, "\n");
+	print("	length	", addr.length, "\n");
+	print("	name	", addr.name\X, "\n");
+	print("	uid	", addr.uid\X, "\n");
+	print("	gid	", addr.gid\X, "\n");
+	print("	muid	", addr.muid\X, "\n");
+};
+
+sizeofWaitmsg = 20;
+aggr Waitmsg
+{
+	'D' 0 pid;
+	'a' 4 time;
+	'X' 16 msg;
+};
+
+defn
+Waitmsg(addr) {
+	complex Waitmsg addr;
+	print("	pid	", addr.pid, "\n");
+	print("	time	", addr.time, "\n");
+	print("	msg	", addr.msg\X, "\n");
+};
+
+sizeofIOchunk = 8;
+aggr IOchunk
+{
+	'X' 0 addr;
+	'U' 4 len;
+};
+
+defn
+IOchunk(addr) {
+	complex IOchunk addr;
+	print("	addr	", addr.addr\X, "\n");
+	print("	len	", addr.len, "\n");
+};
+
+IPaddrlen = 16;
+IPv4addrlen = 4;
+IPv4off = 12;
+IPllen = 4;
+sizeofIplifc = 60;
+aggr Iplifc
+{
+	'A' Iplifc 0 next;
+	'a' 4 ip;
+	'a' 20 mask;
+	'a' 36 net;
+	'U' 52 preflt;
+	'U' 56 validlt;
+};
+
+defn
+Iplifc(addr) {
+	complex Iplifc addr;
+	print("	next	", addr.next\X, "\n");
+	print("	ip	", addr.ip, "\n");
+	print("	mask	", addr.mask, "\n");
+	print("	net	", addr.net, "\n");
+	print("	preflt	", addr.preflt, "\n");
+	print("	validlt	", addr.validlt, "\n");
+};
+
+sizeofIpv6rp = 36;
+aggr Ipv6rp
+{
+	'D' 0 mflag;
+	'D' 4 oflag;
+	'D' 8 maxraint;
+	'D' 12 minraint;
+	'D' 16 linkmtu;
+	'D' 20 reachtime;
+	'D' 24 rxmitra;
+	'D' 28 ttl;
+	'D' 32 routerlt;
+};
+
+defn
+Ipv6rp(addr) {
+	complex Ipv6rp addr;
+	print("	mflag	", addr.mflag, "\n");
+	print("	oflag	", addr.oflag, "\n");
+	print("	maxraint	", addr.maxraint, "\n");
+	print("	minraint	", addr.minraint, "\n");
+	print("	linkmtu	", addr.linkmtu, "\n");
+	print("	reachtime	", addr.reachtime, "\n");
+	print("	rxmitra	", addr.rxmitra, "\n");
+	print("	ttl	", addr.ttl, "\n");
+	print("	routerlt	", addr.routerlt, "\n");
+};
+
+sizeofIpifc = 136;
+aggr Ipifc
+{
+	'A' Ipifc 0 next;
+	'A' Iplifc 4 lifc;
+	'D' 8 index;
+	'a' 12 dev;
+	'b' 76 sendra6;
+	'b' 77 recvra6;
+	'D' 80 mtu;
+	'U' 84 pktin;
+	'U' 88 pktout;
+	'U' 92 errin;
+	'U' 96 errout;
+	Ipv6rp 100 rp;
+};
+
+defn
+Ipifc(addr) {
+	complex Ipifc addr;
+	print("	next	", addr.next\X, "\n");
+	print("	lifc	", addr.lifc\X, "\n");
+	print("	index	", addr.index, "\n");
+	print("	dev	", addr.dev, "\n");
+	print("	sendra6	", addr.sendra6, "\n");
+	print("	recvra6	", addr.recvra6, "\n");
+	print("	mtu	", addr.mtu, "\n");
+	print("	pktin	", addr.pktin, "\n");
+	print("	pktout	", addr.pktout, "\n");
+	print("	errin	", addr.errin, "\n");
+	print("	errout	", addr.errout, "\n");
+	print("Ipv6rp rp {\n");
+	Ipv6rp(addr.rp);
+	print("}\n");
+};
+
+OUdphdrsize = 36;
+sizeofOUdphdr = 36;
+aggr OUdphdr
+{
+	'a' 0 raddr;
+	'a' 16 laddr;
+	'a' 32 rport;
+	'a' 34 lport;
+};
+
+defn
+OUdphdr(addr) {
+	complex OUdphdr addr;
+	print("	raddr	", addr.raddr, "\n");
+	print("	laddr	", addr.laddr, "\n");
+	print("	rport	", addr.rport, "\n");
+	print("	lport	", addr.lport, "\n");
+};
+
+Udphdrsize = 52;
+sizeofUdphdr = 52;
+aggr Udphdr
+{
+	'a' 0 raddr;
+	'a' 16 laddr;
+	'a' 32 ifcaddr;
+	'a' 48 rport;
+	'a' 50 lport;
+};
+
+defn
+Udphdr(addr) {
+	complex Udphdr addr;
+	print("	raddr	", addr.raddr, "\n");
+	print("	laddr	", addr.laddr, "\n");
+	print("	ifcaddr	", addr.ifcaddr, "\n");
+	print("	rport	", addr.rport, "\n");
+	print("	lport	", addr.lport, "\n");
+};
+
+sizeofPool = 88;
+aggr Pool
+{
+	'X' 0 name;
+	'U' 4 maxsize;
+	'U' 8 cursize;
+	'U' 12 curfree;
+	'U' 16 curalloc;
+	'U' 20 minarena;
+	'U' 24 quantum;
+	'U' 28 minblock;
+	'X' 32 freeroot;
+	'X' 36 arenalist;
+	'X' 40 alloc;
+	'X' 44 merge;
+	'X' 48 move;
+	'D' 52 flags;
+	'D' 56 nfree;
+	'D' 60 lastcompact;
+	'X' 64 lock;
+	'X' 68 unlock;
+	'X' 72 print;
+	'X' 76 panic;
+	'X' 80 logstack;
+	'X' 84 private;
+};
+
+defn
+Pool(addr) {
+	complex Pool addr;
+	print("	name	", addr.name\X, "\n");
+	print("	maxsize	", addr.maxsize, "\n");
+	print("	cursize	", addr.cursize, "\n");
+	print("	curfree	", addr.curfree, "\n");
+	print("	curalloc	", addr.curalloc, "\n");
+	print("	minarena	", addr.minarena, "\n");
+	print("	quantum	", addr.quantum, "\n");
+	print("	minblock	", addr.minblock, "\n");
+	print("	freeroot	", addr.freeroot\X, "\n");
+	print("	arenalist	", addr.arenalist\X, "\n");
+	print("	alloc	", addr.alloc\X, "\n");
+	print("	merge	", addr.merge\X, "\n");
+	print("	move	", addr.move\X, "\n");
+	print("	flags	", addr.flags, "\n");
+	print("	nfree	", addr.nfree, "\n");
+	print("	lastcompact	", addr.lastcompact, "\n");
+	print("	lock	", addr.lock\X, "\n");
+	print("	unlock	", addr.unlock\X, "\n");
+	print("	print	", addr.print\X, "\n");
+	print("	panic	", addr.panic\X, "\n");
+	print("	logstack	", addr.logstack\X, "\n");
+	print("	private	", addr.private\X, "\n");
+};
+
+complex Pool mainmem;
+complex Pool imagmem;
+POOL_ANTAGONISM = 1;
+POOL_PARANOIA = 2;
+POOL_VERBOSITY = 4;
+POOL_DEBUGGING = 8;
+POOL_LOGGING = 16;
+POOL_TOLERANCE = 32;
+POOL_NOREUSE = 64;
+Ta = 1;
+Tns = 2;
+Tmd = 3;
+Tmf = 4;
+Tcname = 5;
+Tsoa = 6;
+Tmb = 7;
+Tmg = 8;
+Tmr = 9;
+Tnull = 10;
+Twks = 11;
+Tptr = 12;
+Thinfo = 13;
+Tminfo = 14;
+Tmx = 15;
+Ttxt = 16;
+Trp = 17;
+Tafsdb = 18;
+Tx25 = 19;
+Tisdn = 20;
+Trt = 21;
+Tnsap = 22;
+Tnsapptr = 23;
+Tsig = 24;
+Tkey = 25;
+Tpx = 26;
+Tgpos = 27;
+Taaaa = 28;
+Tloc = 29;
+Tnxt = 30;
+Teid = 31;
+Tnimloc = 32;
+Tsrv = 33;
+Tatma = 34;
+Tnaptr = 35;
+Tkx = 36;
+Tcert = 37;
+Ta6 = 38;
+Tdname = 39;
+Tsink = 40;
+Topt = 41;
+Tapl = 42;
+Tds = 43;
+Tsshfp = 44;
+Tipseckey = 45;
+Trrsig = 46;
+Tnsec = 47;
+Tdnskey = 48;
+Tspf = 99;
+Tuinfo = 100;
+Tuid = 101;
+Tgid = 102;
+Tunspec = 103;
+Ttkey = 249;
+Ttsig = 250;
+Tixfr = 251;
+Taxfr = 252;
+Tmailb = 253;
+Tmaila = 254;
+Tall = 255;
+Csym = 0;
+Cin = 1;
+Ccs = 2;
+Cch = 3;
+Chs = 4;
+Call = 255;
+Oquery = 0;
+Oinverse = 2048;
+Ostatus = 4096;
+Onotify = 8192;
+Oupdate = 10240;
+Omask = 30720;
+Rok = 0;
+Rformat = 1;
+Rserver = 2;
+Rname = 3;
+Runimplimented = 4;
+Rrefused = 5;
+Ryxdomain = 6;
+Ryxrrset = 7;
+Rnxrrset = 8;
+Rnotauth = 9;
+Rnotzone = 10;
+Rbadvers = 16;
+Rbadkey = 17;
+Rbadtime = 18;
+Rbadmode = 19;
+Rbadname = 20;
+Rbadalg = 21;
+Rmask = 31;
+Rtimeout = 32;
+Fresp = 32768;
+Fauth = 1024;
+Ftrunc = 512;
+Frecurse = 256;
+Fcanrec = 128;
+Domlen = 256;
+Labellen = 256;
+Strlen = 256;
+Iplen = 32;
+Min = 60;
+Hour = 3600;
+Day = 86400;
+Week = 604800;
+Year = 31449600;
+DEFTTL = 86400;
+Reserved = 300;
+Maxudp = 512;
+Maxudpin = 2048;
+HTLEN = 4096;
+RRmagic = 3735927486;
+DNmagic = 2702221584;
+Maxactive = 32;
+sizeofRequest = 20;
+aggr Request
+{
+	'D' 0 isslave;
+	'U' 4 aborttime;
+	'a' 8 mret;
+	'D' 16 id;
+};
+
+defn
+Request(addr) {
+	complex Request addr;
+	print("	isslave	", addr.isslave, "\n");
+	print("	aborttime	", addr.aborttime, "\n");
+	print("	mret	", addr.mret, "\n");
+	print("	id	", addr.id, "\n");
+};
+
+sizeofDN = 32;
+aggr DN
+{
+	'A' DN 0 next;
+	'U' 4 magic;
+	'X' 8 name;
+	'X' 12 rr;
+	'U' 16 referenced;
+	'U' 20 lookuptime;
+	'u' 24 class;
+	'C' 26 refs;
+	'C' 27 nonexistent;
+	'U' 28 ordinal;
+};
+
+defn
+DN(addr) {
+	complex DN addr;
+	print("	next	", addr.next\X, "\n");
+	print("	magic	", addr.magic, "\n");
+	print("	name	", addr.name\X, "\n");
+	print("	rr	", addr.rr\X, "\n");
+	print("	referenced	", addr.referenced, "\n");
+	print("	lookuptime	", addr.lookuptime, "\n");
+	print("	class	", addr.class, "\n");
+	print("	refs	", addr.refs, "\n");
+	print("	nonexistent	", addr.nonexistent, "\n");
+	print("	ordinal	", addr.ordinal, "\n");
+};
+
+sizeofKey = 20;
+aggr Key
+{
+	'D' 0 flags;
+	'D' 4 proto;
+	'D' 8 alg;
+	'D' 12 dlen;
+	'X' 16 data;
+};
+
+defn
+Key(addr) {
+	complex Key addr;
+	print("	flags	", addr.flags, "\n");
+	print("	proto	", addr.proto, "\n");
+	print("	alg	", addr.alg, "\n");
+	print("	dlen	", addr.dlen, "\n");
+	print("	data	", addr.data\X, "\n");
+};
+
+sizeofCert = 20;
+aggr Cert
+{
+	'D' 0 type;
+	'D' 4 tag;
+	'D' 8 alg;
+	'D' 12 dlen;
+	'X' 16 data;
+};
+
+defn
+Cert(addr) {
+	complex Cert addr;
+	print("	type	", addr.type, "\n");
+	print("	tag	", addr.tag, "\n");
+	print("	alg	", addr.alg, "\n");
+	print("	dlen	", addr.dlen, "\n");
+	print("	data	", addr.data\X, "\n");
+};
+
+sizeofSig = 40;
+aggr Sig
+{
+	'D' 0 type;
+	'D' 4 alg;
+	'D' 8 labels;
+	'U' 12 ttl;
+	'U' 16 exp;
+	'U' 20 incep;
+	'D' 24 tag;
+	'A' DN 28 signer;
+	'D' 32 dlen;
+	'X' 36 data;
+};
+
+defn
+Sig(addr) {
+	complex Sig addr;
+	print("	type	", addr.type, "\n");
+	print("	alg	", addr.alg, "\n");
+	print("	labels	", addr.labels, "\n");
+	print("	ttl	", addr.ttl, "\n");
+	print("	exp	", addr.exp, "\n");
+	print("	incep	", addr.incep, "\n");
+	print("	tag	", addr.tag, "\n");
+	print("	signer	", addr.signer\X, "\n");
+	print("	dlen	", addr.dlen, "\n");
+	print("	data	", addr.data\X, "\n");
+};
+
+sizeofNull = 8;
+aggr Null
+{
+	'D' 0 dlen;
+	'X' 4 data;
+};
+
+defn
+Null(addr) {
+	complex Null addr;
+	print("	dlen	", addr.dlen, "\n");
+	print("	data	", addr.data\X, "\n");
+};
+
+sizeofTxt = 8;
+aggr Txt
+{
+	'A' Txt 0 next;
+	'X' 4 p;
+};
+
+defn
+Txt(addr) {
+	complex Txt addr;
+	print("	next	", addr.next\X, "\n");
+	print("	p	", addr.p\X, "\n");
+};
+
+sizeof_2_ = 4;
+aggr _2_
+{
+	'A' DN 0 negsoaowner;
+	'A' DN 0 host;
+	'A' DN 0 cpu;
+	'A' DN 0 mb;
+	'A' DN 0 ip;
+	'A' DN 0 rp;
+	'D' 0 cruftlen;
+	'U' 0 arg0;
+};
+
+defn
+_2_(addr) {
+	complex _2_ addr;
+	print("	negsoaowner	", addr.negsoaowner\X, "\n");
+	print("	host	", addr.host\X, "\n");
+	print("	cpu	", addr.cpu\X, "\n");
+	print("	mb	", addr.mb\X, "\n");
+	print("	ip	", addr.ip\X, "\n");
+	print("	rp	", addr.rp\X, "\n");
+	print("	cruftlen	", addr.cruftlen, "\n");
+	print("	arg0	", addr.arg0, "\n");
+};
+
+sizeof_3_ = 4;
+aggr _3_
+{
+	'D' 0 negrcode;
+	'A' DN 0 rmb;
+	'A' DN 0 ptr;
+	'A' DN 0 os;
+	'U' 0 pref;
+	'U' 0 $local;
+	'U' 0 arg1;
+};
+
+defn
+_3_(addr) {
+	complex _3_ addr;
+	print("	negrcode	", addr.negrcode, "\n");
+	print("	rmb	", addr.rmb\X, "\n");
+	print("	ptr	", addr.ptr\X, "\n");
+	print("	os	", addr.os\X, "\n");
+	print("	pref	", addr.pref, "\n");
+	print("	$local	", addr.$local, "\n");
+	print("	arg1	", addr.arg1, "\n");
+};
+
+sizeof_4_ = 4;
+aggr _4_
+{
+	'X' 0 soa;
+	'A' Key 0 key;
+	'A' Cert 0 cert;
+	'A' Sig 0 sig;
+	'A' Null 0 null;
+	'A' Txt 0 txt;
+};
+
+defn
+_4_(addr) {
+	complex _4_ addr;
+	print("	soa	", addr.soa\X, "\n");
+	print("	key	", addr.key\X, "\n");
+	print("	cert	", addr.cert\X, "\n");
+	print("	sig	", addr.sig\X, "\n");
+	print("	null	", addr.null\X, "\n");
+	print("	txt	", addr.txt\X, "\n");
+};
+
+sizeofRR = 52;
+aggr RR
+{
+	'A' RR 0 next;
+	'U' 4 magic;
+	'A' DN 8 owner;
+	'b' 12 negative;
+	'U' 16 pc;
+	'U' 20 ttl;
+	'U' 24 expire;
+	'u' 28 type;
+	'u' 30 query;
+	'b' 32 auth;
+	'b' 33 db;
+	'b' 34 cached;
+	'U' 36 marker;
+	{
+	'A' DN 40 negsoaowner;
+	'A' DN 40 host;
+	'A' DN 40 cpu;
+	'A' DN 40 mb;
+	'A' DN 40 ip;
+	'A' DN 40 rp;
+	'D' 40 cruftlen;
+	'U' 40 arg0;
+	};
+	{
+	'D' 44 negrcode;
+	'A' DN 44 rmb;
+	'A' DN 44 ptr;
+	'A' DN 44 os;
+	'U' 44 pref;
+	'U' 44 $local;
+	'U' 44 arg1;
+	};
+	{
+	'X' 48 soa;
+	'A' Key 48 key;
+	'A' Cert 48 cert;
+	'A' Sig 48 sig;
+	'A' Null 48 null;
+	'A' Txt 48 txt;
+	};
+};
+
+defn
+RR(addr) {
+	complex RR addr;
+	print("	next	", addr.next\X, "\n");
+	print("	magic	", addr.magic, "\n");
+	print("	owner	", addr.owner\X, "\n");
+	print("	negative	", addr.negative, "\n");
+	print("	pc	", addr.pc, "\n");
+	print("	ttl	", addr.ttl, "\n");
+	print("	expire	", addr.expire, "\n");
+	print("	type	", addr.type, "\n");
+	print("	query	", addr.query, "\n");
+	print("	auth	", addr.auth, "\n");
+	print("	db	", addr.db, "\n");
+	print("	cached	", addr.cached, "\n");
+	print("	marker	", addr.marker, "\n");
+	print("_2_ {\n");
+		_2_(addr+40);
+	print("}\n");
+	print("_3_ {\n");
+		_3_(addr+44);
+	print("}\n");
+	print("_4_ {\n");
+		_4_(addr+48);
+	print("}\n");
+};
+
+sizeofServer = 8;
+aggr Server
+{
+	'A' Server 0 next;
+	'X' 4 name;
+};
+
+defn
+Server(addr) {
+	complex Server addr;
+	print("	next	", addr.next\X, "\n");
+	print("	name	", addr.name\X, "\n");
+};
+
+sizeofSOA = 24;
+aggr SOA
+{
+	'U' 0 serial;
+	'U' 4 refresh;
+	'U' 8 retry;
+	'U' 12 expire;
+	'U' 16 minttl;
+	'A' Server 20 slaves;
+};
+
+defn
+SOA(addr) {
+	complex SOA addr;
+	print("	serial	", addr.serial, "\n");
+	print("	refresh	", addr.refresh, "\n");
+	print("	retry	", addr.retry, "\n");
+	print("	expire	", addr.expire, "\n");
+	print("	minttl	", addr.minttl, "\n");
+	print("	slaves	", addr.slaves\X, "\n");
+};
+
+sizeofDNSmsg = 40;
+aggr DNSmsg
+{
+	'u' 0 id;
+	'D' 4 flags;
+	'D' 8 qdcount;
+	'A' RR 12 qd;
+	'D' 16 ancount;
+	'A' RR 20 an;
+	'D' 24 nscount;
+	'A' RR 28 ns;
+	'D' 32 arcount;
+	'A' RR 36 ar;
+};
+
+defn
+DNSmsg(addr) {
+	complex DNSmsg addr;
+	print("	id	", addr.id, "\n");
+	print("	flags	", addr.flags, "\n");
+	print("	qdcount	", addr.qdcount, "\n");
+	print("	qd	", addr.qd\X, "\n");
+	print("	ancount	", addr.ancount, "\n");
+	print("	an	", addr.an\X, "\n");
+	print("	nscount	", addr.nscount, "\n");
+	print("	ns	", addr.ns\X, "\n");
+	print("	arcount	", addr.arcount, "\n");
+	print("	ar	", addr.ar\X, "\n");
+};
+
+sizeofArea = 20;
+aggr Area
+{
+	'A' Area 0 next;
+	'D' 4 len;
+	'A' RR 8 soarr;
+	'D' 12 neednotify;
+	'D' 16 needrefresh;
+};
+
+defn
+Area(addr) {
+	complex Area addr;
+	print("	next	", addr.next\X, "\n");
+	print("	len	", addr.len, "\n");
+	print("	soarr	", addr.soarr\X, "\n");
+	print("	neednotify	", addr.neednotify, "\n");
+	print("	needrefresh	", addr.needrefresh, "\n");
+};
+
+Recurse = 0;
+Dontrecurse = 1;
+NOneg = 2;
+OKneg = 3;
+complex Area owned;
+complex Area delegated;
+sizeof_5_ = 24;
+aggr _5_
+{
+	{
+	'D' 0 val;
+	};
+	'U' 4 names;
+	'U' 8 oldest;
+	'D' 12 active;
+	'D' 16 mutex;
+	'D' 20 id;
+};
+
+defn
+_5_(addr) {
+	complex _5_ addr;
+	print("Lock {\n");
+		Lock(addr+0);
+	print("}\n");
+	print("	names	", addr.names, "\n");
+	print("	oldest	", addr.oldest, "\n");
+	print("	active	", addr.active, "\n");
+	print("	mutex	", addr.mutex, "\n");
+	print("	id	", addr.id, "\n");
+};
+
+complex _5_ dnvars;
+complex Lock dnlock;
+complex DN dnlookup:l;
+complex DN dnlookup:dp;
+complex DN dndump:dp;
+complex RR dndump:rp;
+complex DN dnpurge:dp;
+complex RR dnpurge:rp;
+complex RR dnpurge:srp;
+complex DN dnage:dp;
+complex RR dnage:l;
+complex RR dnage:rp;
+complex RR dnage:next;
+complex DN dnageall:dp;
+complex DN dnageall:l;
+complex RR dnageall:rp;
+complex DN dnagedb:dp;
+complex RR dnagedb:rp;
+complex DN dnauthdb:dp;
+complex Area dnauthdb:area;
+complex RR dnauthdb:rp;
+complex Request getactivity:req;
+complex RR rrattach1:new;
+complex RR rrattach1:l;
+complex RR rrattach1:rp;
+complex DN rrattach1:dp;
+complex RR rrattach:rp;
+complex RR rrattach:next;
+complex RR rralloc:rp;
+complex RR rrfree:rp;
+complex DN rrfree:dp;
+complex RR rrfree:nrp;
+complex Txt rrfree:t;
+complex RR rrfreelist:rp;
+complex RR rrfreelist:next;
+complex RR rrcopy:rp;
+complex RR rrcopy:last;
+complex RR rrcopy:nrp;
+complex SOA rrcopy:soa;
+complex Key rrcopy:key;
+complex Cert rrcopy:cert;
+complex Sig rrcopy:sig;
+complex Null rrcopy:null;
+complex Txt rrcopy:t;
+complex Txt rrcopy:nt;
+complex Txt rrcopy:l;
+complex DN rrlookup:dp;
+complex RR rrlookup:rp;
+complex RR rrlookup:first;
+complex RR rrlookup:last;
+complex RR rrcat:start;
+complex RR rrcat:rp;
+complex RR rrcat:last;
+complex RR rrremneg:l;
+complex RR rrremneg:nl;
+complex RR rrremneg:rp;
+complex RR rrremneg:first;
+complex RR rrremtype:l;
+complex RR rrremtype:nl;
+complex RR rrremtype:rp;
+complex RR rrremtype:first;
+complex Fmt rrfmt:f;
+complex RR rrfmt:rp;
+complex Fmt rrfmt:fstr;
+complex Server rrfmt:s;
+complex Txt rrfmt:t;
+complex Fmt rravfmt:f;
+complex RR rravfmt:rp;
+complex Fmt rravfmt:fstr;
+complex Server rravfmt:s;
+complex Txt rravfmt:t;
+complex Request slave:req;
+complex DN dncheck:dp;
+complex RR dncheck:rp;
+complex Pool mainmem;
+complex RR rrequiv:r1;
+complex RR rrequiv:r2;
+complex RR unique:rp;
+complex RR unique:l;
+complex RR unique:nrp;
+complex RR randomize:rp;
+complex RR randomize:first;
+complex RR randomize:last;
+complex RR randomize:x;
+complex RR randomize:base;
+complex Fmt sencodefmt:f;
+complex DN mkptr:dp;
+complex DN mkptr:ipdp;
+complex RR mkptr:rp;
+complex DN dnptr:dp;
+complex RR dnptr:rp;
+complex RR dnptr:nrp;
+complex RR dnptr:first;
+complex RR dnptr:l;
+complex Server freeserverlist:s;
+complex Server freeserverlist:next;
+complex Server addserver:l;
+complex Server addserver:s;
+complex Server copyserverlist:s;
+complex Server copyserverlist:ns;

sys/src/cmd/ndb/dn.c

@@ -9,15 +9,17 @@
  *  Hash table for domain names.  The hash is based only on the
  *  first element of the domain name.
  */
-DN *ht[HTLEN];
+DN	*ht[HTLEN];
 
-static struct {
+
+static struct
+{
 	Lock;
 	ulong	names;	/* names allocated */
 	ulong	oldest;	/* longest we'll leave a name around */
 	int	active;
 	int	mutex;
-	ushort	id;	/* same size as in packet */
+	int	id;
 } dnvars;
 
 /* names of RR types */
@@ -108,7 +110,6 @@ char *rname[Rmask+1] =
 [Rbadname]		"duplicate key name",
 [Rbadalg]		"bad algorithm",
 };
-unsigned nrname = nelem(rname);
 
 /* names of op codes */
 char *opname[] =
@@ -123,6 +124,9 @@ Lock	dnlock;
 
 static int sencodefmt(Fmt*);
 
+/*
+ *  set up a pipe to use as a lock
+ */
 void
 dninit(void)
 {
@@ -135,7 +139,6 @@ dninit(void)
 
 	dnvars.oldest = maxage;
 	dnvars.names = 0;
-	dnvars.id = truerand();	/* don't start with same id every time */
 }
 
 /*
@@ -148,7 +151,7 @@ dnhash(char *name)
 	uchar *val = (uchar*)name;
 
 	for(hash = 0; *val; val++)
-		hash = hash*13 + tolower(*val)-'a';
+		hash = (hash*13) + tolower(*val)-'a';
 	return hash % HTLEN;
 }
 
@@ -173,8 +176,7 @@ dnlookup(char *name, int class, int enter)
 		}
 		l = &dp->next;
 	}
-
-	if(!enter){
+	if(enter == 0){
 		unlock(&dnlock);
 		return 0;
 	}
@@ -182,7 +184,7 @@ dnlookup(char *name, int class, int enter)
 	dp = emalloc(sizeof(*dp));
 	dp->magic = DNmagic;
 	dp->name = estrdup(name);
-	assert(dp->name != nil);
+	assert(dp->name != 0);
 	dp->class = class;
 	dp->rr = 0;
 	dp->next = 0;
@@ -207,14 +209,14 @@ dndump(char *file)
 	if(fd < 0)
 		return;
 	lock(&dnlock);
-	for(i = 0; i < HTLEN; i++)
+	for(i = 0; i < HTLEN; i++){
 		for(dp = ht[i]; dp; dp = dp->next){
 			fprint(fd, "%s\n", dp->name);
 			for(rp = dp->rr; rp; rp = rp->next)
-				fprint(fd, "	%R %c%c %lud/%lud\n",
-					rp, rp->auth? 'A': 'U',
-					rp->db? 'D': 'N', rp->expire, rp->ttl);
+				fprint(fd, "	%R %c%c %lud/%lud\n", rp, rp->auth?'A':'U',
+					rp->db?'D':'N', rp->expire, rp->ttl);
 		}
+	}
 	unlock(&dnlock);
 	close(fd);
 }
@@ -272,27 +274,12 @@ dnage(DN *dp)
 	}
 }
 
-#define REF(x) upref(x)
-
-static void
-upref(DN *dp)
-{
-	if (dp == nil)
-		return;
-	dp->refs++;
-	assert(dp->refs < 120);		/* make sure it fits in a signed char */
-}
+#define REF(x) if(x) x->refs++
 
 /*
- *  this comment used to say `our target is 4000 names cached, this should
- *  be larger on large servers'.  /lib/ndb at Bell Labs starts off with
- *  about 1780 names, so 4000 is not a lot.
+ *  our target is 4000 names cached, this should be larger on large servers
  */
-enum {
-	Deftarget = 8000,
-};
-
-ulong target = Deftarget;
+#define TARGET 4000
 
 /*
  *  periodicly sweep for old records and remove unreferenced domain names
@@ -307,16 +294,13 @@ dnageall(int doit)
 	RR *rp;
 	static ulong nextage;
 
-	if(dnvars.names < target || (now < nextage && !doit)){
+	if(dnvars.names < TARGET && now < nextage && !doit){
 		dnvars.oldest = maxage;
 		return;
 	}
 
-	if(dnvars.names >= target) {
-		syslog(0, "dns", "more names (%lud) than target (%lud)",
-			dnvars.names, target);
+	if(dnvars.names > TARGET)
 		dnvars.oldest /= 2;
-	}
 	nextage = now + maxage;
 
 	lock(&dnlock);
@@ -387,19 +371,11 @@ dnageall(int doit)
 			if(dp->rr == 0 && dp->refs == 0){
 				assert(dp->magic == DNmagic);
 				*l = dp->next;
-
 				if(dp->name)
 					free(dp->name);
 				dp->magic = ~dp->magic;
 				dnvars.names--;
-				if (canqlock(&dp->querylck))
-					qunlock(&dp->querylck);
-				else
-					syslog(0, "dns",
-				    "dnageall: freeing DN with querylck held");
-				memset(dp, 0, sizeof *dp); /* cause trouble */
 				free(dp);
-
 				continue;
 			}
 			l = &dp->next;
@@ -433,16 +409,14 @@ dnagedb(void)
 }
 
 /*
- *  mark all local db records about my area as authoritative,
- *  time out any others
+ *  mark all local db records about my area as authoritative, time out any others
  */
 void
 dnauthdb(void)
 {
+	DN *dp;
 	int i;
-	ulong minttl;
 	Area *area;
-	DN *dp;
 	RR *rp;
 	static ulong nextage;
 
@@ -455,14 +429,13 @@ dnauthdb(void)
 			for(rp = dp->rr; rp; rp = rp->next)
 				if(rp->db){
 					if(area){
-						minttl = area->soarr->soa->minttl;
-						if(rp->ttl < minttl)
-							rp->ttl = minttl;
+						if(rp->ttl < area->soarr->soa->minttl)
+							rp->ttl = area->soarr->soa->minttl;
 						rp->auth = 1;
 					}
 					if(rp->expire == 0){
 						rp->db = 0;
-						dp->referenced = now-Reserved-1;
+						dp->referenced = now - Reserved - 1;
 					}
 				}
 		}
@@ -479,9 +452,7 @@ getactivity(Request *req, int recursive)
 {
 	int rv;
 
-	if(traceactivity)
-		syslog(0, "dns", "get: %d active by pid %d from %p",
-			dnvars.active, getpid(), getcallerpc(&req));
+	if(traceactivity) syslog(0, "dns", "get %d by %d from %p", dnvars.active, getpid(), getcallerpc(&req));
 	lock(&dnvars);
 	/*
 	 * can't block here if we're already holding one
@@ -489,9 +460,7 @@ getactivity(Request *req, int recursive)
 	 */
 	while(!recursive && dnvars.mutex){
 		unlock(&dnvars);
-		syslog(0, "dns", "get: waiting for dnvars.mutex, pid %d",
-			getpid());
-		sleep(100);			/* was 200 */
+		sleep(200);
 		lock(&dnvars);
 	}
 	rv = ++dnvars.active;
@@ -506,20 +475,17 @@ putactivity(int recursive)
 {
 	static ulong lastclean;
 
-	if(traceactivity)
-		syslog(0, "dns", "put: %d active by pid %d",
-			dnvars.active, getpid());
+	if(traceactivity) syslog(0, "dns", "put %d by %d", dnvars.active, getpid());
 	lock(&dnvars);
 	dnvars.active--;
-	assert(dnvars.active >= 0); /* "dnvars.active %d", dnvars.active */
+	assert(dnvars.active >= 0); /* "dnvars.active %d", dnvars.active */;
 
 	/*
 	 *  clean out old entries and check for new db periodicly
 	 *  can't block here if being called to let go a "recursive" lock
 	 *  or we'll deadlock waiting for ourselves to give up the dnvars.active.
 	 */
-	if (recursive || dnvars.mutex ||
-	    (needrefresh == 0 && dnvars.active > 0)){
+	if(recursive || dnvars.mutex || (needrefresh == 0 && dnvars.active > 0)){
 		unlock(&dnvars);
 		return;
 	}
@@ -528,9 +494,7 @@ putactivity(int recursive)
 	dnvars.mutex = 1;
 	while(dnvars.active > 0){
 		unlock(&dnvars);
-		syslog(0, "dns", "put: waiting for dnvars.active==0, pid %d",
-			getpid());
-		sleep(100);		/* was 100 */
+		sleep(100);
 		lock(&dnvars);
 	}
 	unlock(&dnvars);
@@ -601,8 +565,7 @@ rrattach1(RR *new, int auth)
 			/* all things equal, pick the newer one */
 			if(rp->arg0 == new->arg0 && rp->arg1 == new->arg1){
 				/* new drives out old */
-				if (new->ttl > rp->ttl ||
-				    new->expire > rp->expire){
+				if(new->ttl > rp->ttl || new->expire > rp->expire){
 					*l = rp->next;
 					rp->cached = 0;
 					rrfree(rp);
@@ -617,10 +580,11 @@ rrattach1(RR *new, int auth)
 			 *  the ordering in the list reflects the ordering
 			 *  received or read from the database
 			 */
-			if(rp->type == Tptr)
+			if(rp->type == Tptr){
 				if(!rp->negative && !new->negative
 				&& rp->ptr->ordinal > new->ptr->ordinal)
 					break;
+			}
 		}
 		l = &rp->next;
 	}
@@ -648,7 +612,7 @@ rrattach(RR *rp, int auth)
 	lock(&dnlock);
 	for(; rp; rp = next){
 		next = rp->next;
-		rp->next = nil;
+		rp->next = 0;
 
 		/* avoid any outside spoofing */
 		if(cachedb && !rp->db && inmyarea(rp->owner->name))
@@ -712,53 +676,41 @@ rrfree(RR *rp)
 	if(dp){
 		assert(dp->magic == DNmagic);
 		for(nrp = dp->rr; nrp; nrp = nrp->next)
-			assert(nrp != rp);	/* "rrfree of live rr" */
+			assert(nrp != rp); /* "rrfree of live rr" */;
 	}
 
 	switch(rp->type){
 	case Tsoa:
 		freeserverlist(rp->soa->slaves);
-		memset(rp->soa, 0, sizeof *rp->soa);	/* cause trouble */
 		free(rp->soa);
 		break;
 	case Tkey:
-		memset(rp->key->data, 0, sizeof *rp->key->data); /* cause trouble */
 		free(rp->key->data);
-		memset(rp->key, 0, sizeof *rp->key);	/* cause trouble */
 		free(rp->key);
 		break;
 	case Tcert:
-		memset(rp->cert->data, 0, sizeof *rp->cert->data); /* cause trouble */
 		free(rp->cert->data);
-		memset(rp->cert, 0, sizeof *rp->cert);	/* cause trouble */
 		free(rp->cert);
 		break;
 	case Tsig:
-		memset(rp->sig->data, 0, sizeof *rp->sig->data); /* cause trouble */
 		free(rp->sig->data);
-		memset(rp->sig, 0, sizeof *rp->sig);	/* cause trouble */
 		free(rp->sig);
 		break;
 	case Tnull:
-		memset(rp->null->data, 0, sizeof *rp->null->data); /* cause trouble */
 		free(rp->null->data);
-		memset(rp->null, 0, sizeof *rp->null);	/* cause trouble */
 		free(rp->null);
 		break;
 	case Ttxt:
 		while(rp->txt != nil){
 			t = rp->txt;
 			rp->txt = t->next;
-			memset(t->p, 0, sizeof *t->p);	/* cause trouble */
 			free(t->p);
-			memset(t, 0, sizeof *t);	/* cause trouble */
 			free(t);
 		}
 		break;
 	}
 
 	rp->magic = ~rp->magic;
-	memset(rp, 0, sizeof *rp);		/* cause trouble */
 	free(rp);
 }
 
@@ -776,7 +728,7 @@ rrfreelist(RR *rp)
 	}
 }
 
-RR**
+extern RR**
 rrcopy(RR *rp, RR **last)
 {
 	RR *nrp;
@@ -922,12 +874,13 @@ rrlookup(DN *dp, int type, int flag)
 		goto out;
 
 	/* otherwise, settle for anything we got (except for negative caches)  */
-	for(rp = dp->rr; rp; rp = rp->next)
+	for(rp = dp->rr; rp; rp = rp->next){
 		if(tsame(type, rp->type)){
 			if(rp->negative)
 				goto out;
 			last = rrcopy(rp, last);
 		}
+	}
 
 out:
 	unlock(&dnlock);
@@ -947,7 +900,7 @@ rrtype(char *atype)
 		if(rrtname[i] && strcmp(rrtname[i], atype) == 0)
 			return i;
 
-	/* make any a synonym for all */
+	// make any a synonym for all
 	if(strcmp(atype, "any") == 0)
 		return Tall;
 	return atoi(atype);
@@ -961,10 +914,10 @@ rrname(int type, char *buf, int len)
 {
 	char *t;
 
-	t = nil;
-	if(type >= 0 && type <= Tall)
+	t = 0;
+	if(type <= Tall)
 		t = rrtname[type];
-	if(t==nil){
+	if(t==0){
 		snprint(buf, len, "%d", type);
 		t = buf;
 	}
@@ -979,7 +932,7 @@ rrsupported(int type)
 {
 	if(type < 0 || type >Tall)
 		return 0;
-	return rrtname[type] != nil;
+	return rrtname[type] != 0;
 }
 
 /*
@@ -1001,7 +954,7 @@ rrcat(RR **start, RR *rp)
 	RR **last;
 
 	last = start;
-	while(*last != nil)
+	while(*last != 0)
 		last = &(*last)->next;
 
 	*last = rp;
@@ -1039,8 +992,8 @@ rrremneg(RR **l)
 RR*
 rrremtype(RR **l, int type)
 {
-	RR *first, *rp;
-	RR **nl;
+	RR **nl, *rp;
+	RR *first;
 
 	first = nil;
 	nl = &first;
@@ -1058,36 +1011,29 @@ rrremtype(RR **l, int type)
 	return first;
 }
 
-static char *
-dnname(DN *dn)
-{
-	return dn? dn->name: "<null>";
-}
-
 /*
  *  print conversion for rr records
  */
 int
 rrfmt(Fmt *f)
 {
-	int rv;
+	RR *rp;
 	char *strp;
-	char buf[Domlen];
 	Fmt fstr;
-	RR *rp;
+	int rv;
+	char buf[Domlen];
 	Server *s;
-	SOA *soa;
 	Txt *t;
 
 	fmtstrinit(&fstr);
 
 	rp = va_arg(f->args, RR*);
-	if(rp == nil){
+	if(rp == 0){
 		fmtprint(&fstr, "<null>");
 		goto out;
 	}
 
-	fmtprint(&fstr, "%s %s", dnname(rp->owner),
+	fmtprint(&fstr, "%s %s", rp->owner->name,
 		rrname(rp->type, buf, sizeof buf));
 
 	if(rp->negative){
@@ -1097,51 +1043,42 @@ rrfmt(Fmt *f)
 
 	switch(rp->type){
 	case Thinfo:
-		fmtprint(&fstr, "\t%s %s", dnname(rp->cpu), dnname(rp->os));
+		fmtprint(&fstr, "\t%s %s", rp->cpu->name, rp->os->name);
 		break;
 	case Tcname:
 	case Tmb:
 	case Tmd:
 	case Tmf:
 	case Tns:
-		fmtprint(&fstr, "\t%s", dnname(rp->host));
+		fmtprint(&fstr, "\t%s", rp->host->name);
 		break;
 	case Tmg:
 	case Tmr:
-		fmtprint(&fstr, "\t%s", dnname(rp->mb));
+		fmtprint(&fstr, "\t%s", rp->mb->name);
 		break;
 	case Tminfo:
-		fmtprint(&fstr, "\t%s %s", dnname(rp->mb), dnname(rp->rmb));
+		fmtprint(&fstr, "\t%s %s", rp->mb->name, rp->rmb->name);
 		break;
 	case Tmx:
-		fmtprint(&fstr, "\t%lud %s", rp->pref, dnname(rp->host));
+		fmtprint(&fstr, "\t%lud %s", rp->pref, rp->host->name);
 		break;
 	case Ta:
 	case Taaaa:
-		fmtprint(&fstr, "\t%s", dnname(rp->ip));
+		fmtprint(&fstr, "\t%s", rp->ip->name);
 		break;
 	case Tptr:
-//		fmtprint(&fstr, "\t%s(%lud)", dnname(rp->ptr),
-//			rp->ptr? rp->ptr->ordinal: "<null>");
-		fmtprint(&fstr, "\t%s", dnname(rp->ptr));
+//		fmtprint(&fstr, "\t%s(%lud)", rp->ptr->name, rp->ptr->ordinal);
+		fmtprint(&fstr, "\t%s", rp->ptr->name);
 		break;
 	case Tsoa:
-		soa = rp->soa;
-		fmtprint(&fstr, "\t%s %s %lud %lud %lud %lud %lud",
-			dnname(rp->host), dnname(rp->rmb),
-			(soa? soa->serial: 0),
-			(soa? soa->refresh: 0), (soa? soa->retry: 0),
-			(soa? soa->expire: 0), (soa? soa->minttl: 0));
-		if (soa)
-			for(s = soa->slaves; s != nil; s = s->next)
-				fmtprint(&fstr, " %s", s->name);
+		fmtprint(&fstr, "\t%s %s %lud %lud %lud %lud %lud", rp->host->name,
+			rp->rmb->name, rp->soa->serial, rp->soa->refresh, rp->soa->retry,
+			rp->soa->expire, rp->soa->minttl);
+		for(s = rp->soa->slaves; s != nil; s = s->next)
+			fmtprint(&fstr, " %s", s->name);
 		break;
 	case Tnull:
-		if (rp->null == nil)
-			fmtprint(&fstr, "\t<null>");
-		else
-			fmtprint(&fstr, "\t%.*H", rp->null->dlen,
-				rp->null->data);
+		fmtprint(&fstr, "\t%.*H", rp->null->dlen, rp->null->data);
 		break;
 	case Ttxt:
 		fmtprint(&fstr, "\t");
@@ -1149,31 +1086,22 @@ rrfmt(Fmt *f)
 			fmtprint(&fstr, "%s", t->p);
 		break;
 	case Trp:
-		fmtprint(&fstr, "\t%s %s", dnname(rp->rmb), dnname(rp->rp));
+		fmtprint(&fstr, "\t%s %s", rp->rmb->name, rp->rp->name);
 		break;
 	case Tkey:
-		if (rp->key == nil)
-			fmtprint(&fstr, "\t<null> <null> <null>");
-		else
-			fmtprint(&fstr, "\t%d %d %d", rp->key->flags,
-				rp->key->proto, rp->key->alg);
+		fmtprint(&fstr, "\t%d %d %d", rp->key->flags, rp->key->proto,
+			rp->key->alg);
 		break;
 	case Tsig:
-		if (rp->sig == nil)
-			fmtprint(&fstr,
-		   "\t<null> <null> <null> <null> <null> <null> <null> <null>");
-		else
-			fmtprint(&fstr, "\t%d %d %d %lud %lud %lud %d %s",
-				rp->sig->type, rp->sig->alg, rp->sig->labels,
-				rp->sig->ttl, rp->sig->exp, rp->sig->incep,
-				rp->sig->tag, dnname(rp->sig->signer));
+		fmtprint(&fstr, "\t%d %d %d %lud %lud %lud %d %s",
+			rp->sig->type, rp->sig->alg, rp->sig->labels, rp->sig->ttl,
+			rp->sig->exp, rp->sig->incep, rp->sig->tag, rp->sig->signer->name);
 		break;
 	case Tcert:
-		if (rp->cert == nil)
-			fmtprint(&fstr, "\t<null> <null> <null>");
-		else
-			fmtprint(&fstr, "\t%d %d %d",
-				rp->cert->type, rp->cert->tag, rp->cert->alg);
+		fmtprint(&fstr, "\t%d %d %d",
+			rp->sig->type, rp->sig->tag, rp->sig->alg);
+		break;
+	default:
 		break;
 	}
 out:
@@ -1189,78 +1117,69 @@ out:
 int
 rravfmt(Fmt *f)
 {
-	int rv, quote;
+	RR *rp;
 	char *strp;
 	Fmt fstr;
-	RR *rp;
+	int rv;
 	Server *s;
-	SOA *soa;
 	Txt *t;
+	int quote;
 
 	fmtstrinit(&fstr);
 
 	rp = va_arg(f->args, RR*);
-	if(rp == nil){
+	if(rp == 0){
 		fmtprint(&fstr, "<null>");
 		goto out;
 	}
 
 	if(rp->type == Tptr)
-		fmtprint(&fstr, "ptr=%s", dnname(rp->owner));
+		fmtprint(&fstr, "ptr=%s", rp->owner->name);
 	else
-		fmtprint(&fstr, "dom=%s", dnname(rp->owner));
+		fmtprint(&fstr, "dom=%s", rp->owner->name);
 
 	switch(rp->type){
 	case Thinfo:
-		fmtprint(&fstr, " cpu=%s os=%s",
-			dnname(rp->cpu), dnname(rp->os));
+		fmtprint(&fstr, " cpu=%s os=%s", rp->cpu->name, rp->os->name);
 		break;
 	case Tcname:
-		fmtprint(&fstr, " cname=%s", dnname(rp->host));
+		fmtprint(&fstr, " cname=%s", rp->host->name);
 		break;
 	case Tmb:
 	case Tmd:
 	case Tmf:
-		fmtprint(&fstr, " mbox=%s", dnname(rp->host));
+		fmtprint(&fstr, " mbox=%s", rp->host->name);
 		break;
 	case Tns:
-		fmtprint(&fstr,  " ns=%s", dnname(rp->host));
+		fmtprint(&fstr,  " ns=%s", rp->host->name);
 		break;
 	case Tmg:
 	case Tmr:
-		fmtprint(&fstr, " mbox=%s", dnname(rp->mb));
+		fmtprint(&fstr, " mbox=%s", rp->mb->name);
 		break;
 	case Tminfo:
-		fmtprint(&fstr, " mbox=%s mbox=%s",
-			dnname(rp->mb), dnname(rp->rmb));
+		fmtprint(&fstr, " mbox=%s mbox=%s", rp->mb->name, rp->rmb->name);
 		break;
 	case Tmx:
-		fmtprint(&fstr, " pref=%lud mx=%s", rp->pref, dnname(rp->host));
+		fmtprint(&fstr, " pref=%lud mx=%s", rp->pref, rp->host->name);
 		break;
 	case Ta:
 	case Taaaa:
-		fmtprint(&fstr, " ip=%s", dnname(rp->ip));
+		fmtprint(&fstr, " ip=%s", rp->ip->name);
 		break;
 	case Tptr:
-		fmtprint(&fstr, " dom=%s", dnname(rp->ptr));
+		fmtprint(&fstr, " dom=%s", rp->ptr->name);
 		break;
 	case Tsoa:
-		soa = rp->soa;
-		fmtprint(&fstr,
-" ns=%s mbox=%s serial=%lud refresh=%lud retry=%lud expire=%lud ttl=%lud",
-			dnname(rp->host), dnname(rp->rmb),
-			(soa? soa->serial: 0),
-			(soa? soa->refresh: 0), (soa? soa->retry: 0),
-			(soa? soa->expire: 0), (soa? soa->minttl: 0));
-		for(s = soa->slaves; s != nil; s = s->next)
+		fmtprint(&fstr, " ns=%s mbox=%s serial=%lud refresh=%lud retry=%lud expire=%lud ttl=%lud",
+			rp->host->name, rp->rmb->name, rp->soa->serial,
+			rp->soa->refresh, rp->soa->retry,
+			rp->soa->expire, rp->soa->minttl);
+		for(s = rp->soa->slaves; s != nil; s = s->next)
 			fmtprint(&fstr, " dnsslave=%s", s->name);
 		break;
 	case Tnull:
-		if (rp->null == nil)
-			fmtprint(&fstr, " null=<null>");
-		else
-			fmtprint(&fstr, " null=%.*H", rp->null->dlen,
-				rp->null->data);
+		fmtprint(&fstr, " null=%.*H", rp->null->dlen, rp->null->data);
 		break;
 	case Ttxt:
 		fmtprint(&fstr, " txt=");
@@ -1276,33 +1195,22 @@ rravfmt(Fmt *f)
 			fmtprint(&fstr, "\"");
 		break;
 	case Trp:
-		fmtprint(&fstr, " rp=%s txt=%s",
-			dnname(rp->rmb), dnname(rp->rp));
+		fmtprint(&fstr, " rp=%s txt=%s", rp->rmb->name, rp->rp->name);
 		break;
 	case Tkey:
-		if (rp->key == nil)
-			fmtprint(&fstr, " flags=<null> proto=<null> alg=<null>");
-		else
-			fmtprint(&fstr, " flags=%d proto=%d alg=%d",
-				rp->key->flags, rp->key->proto, rp->key->alg);
+		fmtprint(&fstr, " flags=%d proto=%d alg=%d",
+			rp->key->flags, rp->key->proto, rp->key->alg);
 		break;
 	case Tsig:
-		if (rp->sig == nil)
-			fmtprint(&fstr,
-" type=<null> alg=<null> labels=<null> ttl=<null> exp=<null> incep=<null> tag=<null> signer=<null>");
-		else
-			fmtprint(&fstr,
-" type=%d alg=%d labels=%d ttl=%lud exp=%lud incep=%lud tag=%d signer=%s",
-				rp->sig->type, rp->sig->alg, rp->sig->labels,
-				rp->sig->ttl, rp->sig->exp, rp->sig->incep,
-				rp->sig->tag, dnname(rp->sig->signer));
+		fmtprint(&fstr, " type=%d alg=%d labels=%d ttl=%lud exp=%lud incep=%lud tag=%d signer=%s",
+			rp->sig->type, rp->sig->alg, rp->sig->labels, rp->sig->ttl,
+			rp->sig->exp, rp->sig->incep, rp->sig->tag, rp->sig->signer->name);
 		break;
 	case Tcert:
-		if (rp->cert == nil)
-			fmtprint(&fstr, " type=<null> tag=<null> alg=<null>");
-		else
-			fmtprint(&fstr, " type=%d tag=%d alg=%d",
-				rp->cert->type, rp->cert->tag, rp->cert->alg);
+		fmtprint(&fstr, " type=%d tag=%d alg=%d",
+			rp->sig->type, rp->sig->tag, rp->sig->alg);
+		break;
+	default:
 		break;
 	}
 out:
@@ -1324,31 +1232,6 @@ warning(char *fmt, ...)
 	syslog(1, "dns", dnserr);
 }
 
-/*
- * based on libthread's threadsetname, but drags in less library code.
- * actually just sets the arguments displayed.
- */
-void
-procsetname(char *fmt, ...)
-{
-	int fd;
-	char *cmdname;
-	char buf[128];
-	va_list arg;
-
-	va_start(arg, fmt);
-	cmdname = vsmprint(fmt, arg);
-	va_end(arg);
-	if (cmdname == nil)
-		return;
-	snprint(buf, sizeof buf, "#p/%d/args", getpid());
-	if((fd = open(buf, OWRITE)) >= 0){
-		write(fd, cmdname, strlen(cmdname)+1);
-		close(fd);
-	}
-	free(cmdname);
-}
-
 /*
  *  create a slave process to handle a request to avoid one request blocking
  *  another
@@ -1356,13 +1239,14 @@ procsetname(char *fmt, ...)
 void
 slave(Request *req)
 {
+	static int slaveid;
 	int ppid;
 
 	if(req->isslave)
 		return;		/* we're already a slave process */
 
 	/*
-	 * These calls to putactivity cannot block.
+	 * These calls to putactivity cannot block. 
 	 * After getactivity(), the current process is counted
 	 * twice in dnvars.active (one will pass to the child).
 	 * If putactivity tries to wait for dnvars.active == 0,
@@ -1371,31 +1255,21 @@ slave(Request *req)
 
 	/* limit parallelism */
 	if(getactivity(req, 1) > Maxactive){
-		if(traceactivity)
-			syslog(0, "dns", "[%d] too much activity", getpid());
+		if(traceactivity) syslog(0, "dns", "[%d] too much activity", getpid());
 		putactivity(1);
 		return;
 	}
 
-	/* parent returns to main loop, child does the work */
 	ppid = getpid();
 	switch(rfork(RFPROC|RFNOTEG|RFMEM|RFNOWAIT)){
 	case -1:
 		putactivity(1);
 		break;
 	case 0:
-		procsetname("request slave of pid %d", ppid);
- 		if(traceactivity)
-			syslog(0, "dns", "[%d] take activity from %d",
-				getpid(), ppid);
-		req->isslave = 1;	/* why not `= getpid()'? */
+		if(traceactivity) syslog(0, "dns", "[%d] take activity from %d", ppid, getpid());
+		req->isslave = 1;
 		break;
 	default:
-		/*
-		 * this relies on rfork producing separate, initially-identical
-		 * stacks, thus giving us two copies of `req', one in each
-		 * process.
-		 */
 		longjmp(req->mret, 1);
 	}
 }
@@ -1409,6 +1283,7 @@ dncheck(void *p, int dolock)
 	int i;
 	DN *dp;
 	RR *rp;
+	extern Pool *mainmem;
 
 	if(p != nil){
 		dp = p;
@@ -1451,12 +1326,13 @@ unique(RR *rp)
 
 	for(; rp; rp = rp->next){
 		l = &rp->next;
-		for(nrp = *l; nrp; nrp = *l)
+		for(nrp = *l; nrp; nrp = *l){
 			if(rrequiv(rp, nrp)){
 				*l = nrp->next;
 				rrfree(nrp);
 			} else
 				l = &nrp->next;
+		}
 	}
 }
 
@@ -1470,9 +1346,15 @@ subsume(char *higher, char *lower)
 
 	ln = strlen(lower);
 	hn = strlen(higher);
-	if (ln < hn || cistrcmp(lower + ln - hn, higher) != 0 ||
-	    ln > hn && hn != 0 && lower[ln - hn - 1] != '.')
+	if(ln < hn)
+		return 0;
+
+	if(cistrcmp(lower + ln - hn, higher) != 0)
 		return 0;
+
+	if(ln > hn && hn != 0 && lower[ln - hn - 1] != '.')
+		return 0;
+
 	return 1;
 }
 
@@ -1496,7 +1378,7 @@ randomize(RR *rp)
 		if(x->type != Ta && x->type != Tmx && x->type != Tns)
 			return rp;
 
-	base = rp;
+	base = rp; 
 
 	n = rand();
 	last = first = nil;
@@ -1536,10 +1418,13 @@ randomize(RR *rp)
 static int
 sencodefmt(Fmt *f)
 {
-	int i, len, ilen, rv;
-	char *out, *buf;
+	char *out;
+	char *buf;
+	int i, len;
+	int ilen;
+	int rv;
 	uchar *b;
-	char obuf[64];		/* rsc optimization */
+	char obuf[64];	// rsc optimization
 
 	if(!(f->flags&FmtPrec) || f->prec < 1)
 		goto error;
@@ -1586,7 +1471,7 @@ sencodefmt(Fmt *f)
 	} else
 		buf = obuf;
 
-	/* convert */
+	// convert
 	out = buf;
 	switch(f->r){
 	case '<':
@@ -1612,6 +1497,7 @@ sencodefmt(Fmt *f)
 
 error:
 	return fmtstrcpy(f, "<encodefmt>");
+
 }
 
 void*
@@ -1669,16 +1555,17 @@ void
 dnptr(uchar *net, uchar *mask, char *dom, int bytes, int ttl)
 {
 	int i, j;
-	char *p, *e;
-	char ptr[Domlen];
-	uchar ip[IPaddrlen], nnet[IPaddrlen];
 	DN *dp;
 	RR *rp, *nrp, *first, **l;
+	uchar ip[IPaddrlen];
+	uchar nnet[IPaddrlen];
+	char ptr[Domlen];
+	char *p, *e;
 
 	l = &first;
 	first = nil;
-	for(i = 0; i < HTLEN; i++)
-		for(dp = ht[i]; dp; dp = dp->next)
+	for(i = 0; i < HTLEN; i++){
+		for(dp = ht[i]; dp; dp = dp->next){
 			for(rp = dp->rr; rp; rp = rp->next){
 				if(rp->type != Ta || rp->negative)
 					continue;
@@ -1695,6 +1582,8 @@ dnptr(uchar *net, uchar *mask, char *dom, int bytes, int ttl)
 				*l = nrp;
 				l = &nrp->next;
 			}
+		}
+	}
 
 	for(rp = first; rp != nil; rp = nrp){
 		nrp = rp->next;
@@ -1735,6 +1624,7 @@ copyserverlist(Server *s)
 {
 	Server *ns;
 
+	
 	for(ns = nil; s != nil; s = s->next)
 		addserver(&ns, s->name);
 	return ns;

sys/src/cmd/ndb/dnarea.c

@@ -5,7 +5,8 @@
 #include <ip.h>
 #include "dns.h"
 
-Area *owned, *delegated;
+Area *owned;
+Area *delegated;
 
 /*
  *  true if a name is in our area
@@ -24,19 +25,18 @@ inmyarea(char *name)
 			if(len == s->len || name[len - s->len - 1] == '.')
 				break;
 	}
-	if(s == nil)
-		return nil;
+	if(s == 0)
+		return 0;
 
-	/* name is in area `s' */
 	for(d = delegated; d; d = d->next){
 		if(d->len > len)
 			continue;
 		if(cistrcmp(d->soarr->owner->name, name + len - d->len) == 0)
 			if(len == d->len || name[len - d->len - 1] == '.')
-				return nil; /* name is in a delegated subarea */
+				return 0;
 	}
 
-	return s;	/* name is in area `s' and not in a delegated subarea */
+	return s;
 }
 
 /*
@@ -46,18 +46,13 @@ inmyarea(char *name)
 void
 addarea(DN *dp, RR *rp, Ndbtuple *t)
 {
-	Area *s;
-	Area **l;
+	Area **l, *s;
 
 	if(t->val[0])
 		l = &delegated;
 	else
 		l = &owned;
 
-	for (s = *l; s != nil; s = s->next)
-		if (strcmp(dp->name, s->soarr->owner->name) == 0)
-			return;		/* we've already got one */
-
 	/*
 	 *  The area contains a copy of the soa rr that created it.
 	 *  The owner of the the soa rr should stick around as long
@@ -72,8 +67,7 @@ addarea(DN *dp, RR *rp, Ndbtuple *t)
 	s->neednotify = 1;
 	s->needrefresh = 0;
 
-	syslog(0, logfile, "new area %s %s", dp->name,
-		l == &delegated? "delegated": "owned");
+syslog(0, logfile, "new area %s", dp->name);
 
 	s->next = *l;
 	*l = s;
@@ -87,7 +81,6 @@ freearea(Area **l)
 	while(s = *l){
 		*l = s->next;
 		rrfree(s->soarr);
-		memset(s, 0, sizeof *s);	/* cause trouble */
 		free(s);
 	}
 }
@@ -112,21 +105,26 @@ refresh_areas(Area *s)
 			continue;
 		}
 
-		pid = fork();
-		if (pid == -1) {
-			sleep(1000);	/* don't try it again immediately */
-			continue;
-		}
-		if (pid == 0){
-			execl(zonerefreshprogram, "zonerefresh",
-				s->soarr->owner->name, nil);
-			exits("exec zonerefresh failed");
+		switch(pid = fork()){
+		case -1:
+			break;
+		case 0:
+			execl(zonerefreshprogram, "zonerefresh", s->soarr->owner->name, nil);
+			exits(0);
+			break;
+		default:
+			for(;;){
+				w = wait();
+				if(w == nil)
+					break;
+				if(w->pid == pid){
+					if(w->msg == nil || *w->msg == 0)
+						s->needrefresh = 0;
+					free(w);
+					break;
+				}
+				free(w);
+			}
 		}
-		while ((w = wait()) != nil && w->pid != pid)
-			free(w);
-		if (w && w->pid == pid)
-			if(w->msg == nil || *w->msg == '\0')
-				s->needrefresh = 0;
-		free(w);
 	}
 }

sys/src/cmd/ndb/dnnotify.c

@@ -39,14 +39,16 @@ syslog(0, logfile, "notification for %s", repp->qd->owner->name);
 syslog(0, logfile, "serial old %lud new %lud", a->soarr->soa->serial, repp->qd->soa->serial);
 
 	/* do nothing if it didn't change */
-	if(a->soarr->soa->serial != repp->qd->soa->serial)
-		a->needrefresh = 1;
+	if(a->soarr->soa->serial== repp->qd->soa->serial)
+		return;
+
+	a->needrefresh = 1;
 }
 
 static void
 ding(void*, char *msg)
 {
-	if(strstr(msg, "alarm") != nil)
+	if(strstr(msg, "alarm"))
 		noted(NCONT);
 	else
 		noted(NDFLT);
@@ -57,10 +59,11 @@ static void
 send_notify(char *slave, RR *soa, Request *req)
 {
 	int i, len, n, reqno, status, fd;
-	char *err;
-	uchar ibuf[Maxudp+OUdphdrsize], obuf[Maxudp+OUdphdrsize];
+	uchar obuf[Maxudp+OUdphdrsize];
+	uchar ibuf[Maxudp+OUdphdrsize];
 	RR *rp;
 	OUdphdr *up = (OUdphdr*)obuf;
+	char *err;
 	DNSmsg repmsg;
 
 	/* create the request */
@@ -68,9 +71,9 @@ send_notify(char *slave, RR *soa, Request *req)
 	n = mkreq(soa->owner, Cin, obuf, Fauth | Onotify, reqno);
 
 	/* get an address */
-	if(strcmp(ipattr(slave), "ip") == 0)
+	if(strcmp(ipattr(slave), "ip") == 0) {
 		parseip(up->raddr, slave);
-	else {
+	} else {
 		rp = dnresolve(slave, Cin, Ta, req, nil, 0, 1, 1, &status);
 		if(rp == nil)
 			return;
@@ -78,7 +81,7 @@ send_notify(char *slave, RR *soa, Request *req)
 		rrfree(rp);
 	}
 
-	fd = udpport(nil);
+	fd = udpport();
 	if(fd < 0)
 		return;
 
@@ -95,13 +98,13 @@ syslog(0, logfile, "sending %d byte notify to %s/%I.%d about %s", n, slave, up->
 		alarm(0);
 		if(len <= OUdphdrsize)
 			continue;
-		memset(&repmsg, 0, sizeof repmsg);
-		err = convM2DNS(&ibuf[OUdphdrsize], len, &repmsg, nil);
+		err = convM2DNS(&ibuf[OUdphdrsize], len, &repmsg);
 		if(err != nil)
 			continue;
 		if(repmsg.id == reqno && (repmsg.flags & Omask) == Onotify)
 			break;
 	}
+
 	close(fd);
 }
 
@@ -144,9 +147,7 @@ notifyproc(void)
 		return;
 	}
 
-	procsetname("notify slaves");
-	memset(&req, 0, sizeof req);
-	req.isslave = 1;	/* don't fork off subprocesses */
+	req.isslave = 1;	/* son't fork off subprocesses */
 
 	for(;;){
 		getactivity(&req, 0);

sys/src/cmd/ndb/dnresolve.c

@@ -1,9 +1,7 @@
 #include <u.h>
 #include <libc.h>
-#include <ip.h>
-#include <bio.h>
-#include <ndb.h>
 #include "dns.h"
+#include "ip.h"
 
 enum
 {
@@ -11,57 +9,26 @@ enum
 	Maxtrans=	3,	/* maximum transmissions to a server */
 };
 
-int inside, straddle, serve;
-
 static int	netquery(DN*, int, RR*, Request*, int);
 static RR*	dnresolve1(char*, int, int, Request*, int, int);
 
 char *LOG = "dns";
 
-/*
- * reading /proc/pid/args yields either "name" or "name [display args]",
- * so return only display args, if any.
- */
-static char *
-procgetname(void)
-{
-	int fd, n;
-	char *lp, *rp;
-	char buf[256];
-
-	snprint(buf, sizeof buf, "#p/%d/args", getpid());
-	if((fd = open(buf, OREAD)) < 0)
-		return strdup("");
-	*buf = '\0';
-	n = read(fd, buf, sizeof buf-1);
-	close(fd);
-	if (n >= 0)
-		buf[n] = '\0';
-	if ((lp = strchr(buf, '[')) == nil ||
-	    (rp = strrchr(buf, ']')) == nil)
-		return strdup("");
-	*rp = '\0';
-	return strdup(lp+1);
-}
-
 /*
  *  lookup 'type' info for domain name 'name'.  If it doesn't exist, try
  *  looking it up as a canonical name.
  */
 RR*
-dnresolve(char *name, int class, int type, Request *req, RR **cn, int depth,
-	int recurse, int rooted, int *status)
+dnresolve(char *name, int class, int type, Request *req, RR **cn, int depth, int recurse, int rooted, int *status)
 {
 	RR *rp, *nrp, *drp;
 	DN *dp;
 	int loops;
-	char *procname;
 	char nname[Domlen];
 
 	if(status)
 		*status = 0;
 
-	procname = procgetname();
 	/*
 	 *  hack for systems that don't have resolve search
 	 *  lists.  Just look up the simple name in the database.
@@ -70,18 +37,14 @@ dnresolve(char *name, int class, int type, Request *req, RR **cn, int depth,
 		rp = nil;
 		drp = domainlist(class);
 		for(nrp = drp; nrp != nil; nrp = nrp->next){
-			snprint(nname, sizeof nname, "%s.%s", name,
-				nrp->ptr->name);
-			rp = dnresolve(nname, class, type, req, cn, depth,
-				recurse, rooted, status);
+			snprint(nname, sizeof(nname), "%s.%s", name, nrp->ptr->name);
+			rp = dnresolve(nname, class, type, req,cn, depth, recurse, rooted, status);
 			rrfreelist(rrremneg(&rp));
 			if(rp != nil)
 				break;
 		}
 		if(drp != nil)
 			rrfree(drp);
-		procsetname(procname);
-		free(procname);
 		return rp;
 	}
 
@@ -89,16 +52,13 @@ dnresolve(char *name, int class, int type, Request *req, RR **cn, int depth,
 	 *  try the name directly
 	 */
 	rp = dnresolve1(name, class, type, req, depth, recurse);
-	if(rp) {
-		procsetname(procname);
-		free(procname);
+	if(rp)
 		return randomize(rp);
-	}
 
 	/* try it as a canonical name if we weren't told the name didn't exist */
 	dp = dnlookup(name, class, 0);
-	if(type != Tptr && dp->respcode != Rname)
-		for(loops = 0; rp == nil && loops < 32; loops++){
+	if(type != Tptr && dp->nonexistent != Rname){
+		for(loops=0; rp == nil && loops < 32; loops++){
 			rp = dnresolve1(name, class, Tcname, req, depth, recurse);
 			if(rp == nil)
 				break;
@@ -108,40 +68,37 @@ dnresolve(char *name, int class, int type, Request *req, RR **cn, int depth,
 				rp = nil;
 				break;
 			}
-
+	
 			name = rp->host->name;
 			if(cn)
 				rrcat(cn, rp);
 			else
 				rrfreelist(rp);
-
+	
 			rp = dnresolve1(name, class, type, req, depth, recurse);
 		}
+	}
 
 	/* distinction between not found and not good */
-	if(rp == nil && status != nil && dp->respcode != 0)
-		*status = dp->respcode;
+	if(rp == 0 && status != 0 && dp->nonexistent != 0)
+		*status = dp->nonexistent;
 
-	procsetname(procname);
-	free(procname);
 	return randomize(rp);
 }
 
 static RR*
-dnresolve1(char *name, int class, int type, Request *req, int depth,
-	int recurse)
+dnresolve1(char *name, int class, int type, Request *req, int depth, int recurse)
 {
 	DN *dp, *nsdp;
 	RR *rp, *nsrp, *dbnsrp;
 	char *cp;
 
 	if(debug)
-		syslog(0, LOG, "[%d] dnresolve1 %s %d %d",
-			getpid(), name, type, class);
+		syslog(0, LOG, "[%d] dnresolve1 %s %d %d", getpid(), name, type, class);
 
 	/* only class Cin implemented so far */
 	if(class != Cin)
-		return nil;
+		return 0;
 
 	dp = dnlookup(name, class, 1);
 
@@ -149,22 +106,24 @@ dnresolve1(char *name, int class, int type, Request *req, int depth,
 	 *  Try the cache first
 	 */
 	rp = rrlookup(dp, type, OKneg);
-	if(rp)
+	if(rp){
 		if(rp->db){
 			/* unauthenticated db entries are hints */
 			if(rp->auth)
 				return rp;
-		} else
+		} else {
 			/* cached entry must still be valid */
-			if(rp->ttl > now)
+			if(rp->ttl > now){
 				/* but Tall entries are special */
 				if(type != Tall || rp->query == Tall)
 					return rp;
-
+			}
+		}
+	}
 	rrfreelist(rp);
 
 	/*
-	 * try the cache for a canonical name. if found punt
+	 * try the cache for a canonical name. if found punt 
 	 * since we'll find it during the canonical name search
 	 * in dnresolve().
 	 */
@@ -172,7 +131,7 @@ dnresolve1(char *name, int class, int type, Request *req, int depth,
 		rp = rrlookup(dp, Tcname, NOneg);
 		rrfreelist(rp);
 		if(rp)
-			return nil;
+			return 0;
 	}
 
 	/*
@@ -262,8 +221,7 @@ dnresolve1(char *name, int class, int type, Request *req, int depth,
 }
 
 /*
- *  walk a domain name one element to the right.
- *  return a pointer to that element.
+ *  walk a domain name one element to the right.  return a pointer to that element.
  *  in other words, return a pointer to the parent domain name.
  */
 char*
@@ -288,13 +246,14 @@ static char *hmsg = "headers";
 static char *ohmsg = "oldheaders";
 
 int
-udpport(char *mtpt)
+udpport(void)
 {
 	int fd, ctl;
-	char ds[64], adir[64];
+	char ds[64];
+	char adir[64];
 
 	/* get a udp port */
-	snprint(ds, sizeof ds, "%s/udp!*!0", (mtpt? mtpt: "/net"));
+	snprint(ds, sizeof(ds), "%s/udp!*!0", mntpt);
 	ctl = announce(ds, adir);
 	if(ctl < 0){
 		/* warning("can't get udp port"); */
@@ -310,11 +269,14 @@ udpport(char *mtpt)
 	write(ctl, ohmsg, strlen(ohmsg));
 
 	/* grab the data file */
-	snprint(ds, sizeof ds, "%s/data", adir);
+	snprint(ds, sizeof(ds), "%s/data", adir);
 	fd = open(ds, ORDWR);
 	close(ctl);
-	if(fd < 0)
-		warning("can't open udp port %s: %r", ds);
+	if(fd < 0){
+		warning("can't open udp port: %r");
+		return -1;
+	}
+
 	return fd;
 }
 
@@ -338,7 +300,7 @@ mkreq(DN *dp, int type, uchar *buf, int flags, ushort reqno)
 	m.qd->type = type;
 	len = convDNS2M(&m, &buf[OUdphdrsize], Maxudp);
 	if(len < 0)
-		abort();	/* "can't convert" */
+		abort(); /* "can't convert" */;
 	rrfree(m.qd);
 	return len;
 }
@@ -361,12 +323,10 @@ freeanswers(DNSmsg *mp)
 	rrfreelist(mp->an);
 	rrfreelist(mp->ns);
 	rrfreelist(mp->ar);
-	mp->qd = mp->an = mp->ns = mp->ar = nil;
 }
 
 /*
- *  read replies to a request.  ignore any of the wrong type.
- *  wait at most 5 seconds.
+ *  read replies to a request.  ignore any of the wrong type.  wait at most 5 seconds.
  */
 static int
 readreply(int fd, DN *dp, int type, ushort req,
@@ -391,12 +351,12 @@ readreply(int fd, DN *dp, int type, ushort req,
 		len -= OUdphdrsize;
 		if(len < 0)
 			return -1;	/* timed out */
-
+		
 		/* convert into internal format  */
 		memset(mp, 0, sizeof(*mp));
-		err = convM2DNS(&ibuf[OUdphdrsize], len, mp, nil);
+		err = convM2DNS(&ibuf[OUdphdrsize], len, mp);
 		if(err){
-			syslog(0, LOG, "input err: %s: %I", err, ibuf);
+			syslog(0, LOG, "input err %s: %I", err, ibuf);
 			continue;
 		}
 		if(debug)
@@ -413,13 +373,13 @@ readreply(int fd, DN *dp, int type, ushort req,
 			continue;
 		}
 		if(mp->qd->owner != dp){
-			syslog(0, LOG, "%d: owner %s instead of %s: %I",
-				reqp->id, mp->qd->owner->name, dp->name, ibuf);
+			syslog(0, LOG, "%d: owner %s instead of %s: %I", reqp->id,
+				mp->qd->owner->name, dp->name, ibuf);
 			continue;
 		}
 		if(mp->qd->type != type){
-			syslog(0, LOG, "%d: type %d instead of %d: %I",
-				reqp->id, mp->qd->type, type, ibuf);
+			syslog(0, LOG, "%d: type %d instead of %d: %I", reqp->id,
+				mp->qd->type, type, ibuf);
 			continue;
 		}
 
@@ -446,9 +406,10 @@ contains(RR *rp1, RR *rp2)
 			if(trp1->owner == trp2->owner)
 				break;
 		}
-		if(trp1 == nil)
+		if(trp1 == 0)
 			return 0;
 	}
+
 	return 1;
 }
 
@@ -459,7 +420,7 @@ struct Dest
 	uchar	a[IPaddrlen];	/* ip address */
 	DN	*s;		/* name server */
 	int	nx;		/* number of transmissions */
-	int	code;		/* response code; used to clear dp->respcode */
+	int	code;
 };
 
 
@@ -470,119 +431,22 @@ int
 ipisbm(uchar *ip)
 {
 	if(isv4(ip)){
-		if (ip[IPv4off] >= 0xe0 && ip[IPv4off] < 0xf0 ||
-		    ipcmp(ip, IPv4bcast) == 0)
+		if(ip[IPv4off] >= 0xe0 && ip[IPv4off] < 0xf0)
+			return 4;
+		if(ipcmp(ip, IPv4bcast) == 0)
 			return 4;
-	} else
+	} else {
 		if(ip[0] == 0xff)
 			return 6;
-	return 0;
-}
-
-static Ndb *db;
-static Ndbtuple *indoms, *innmsrvs, *outnmsrvs;
-static QLock ndblock;
-
-static void
-loaddomsrvs(Ndb *db)
-{
-	Ndbs s;
-
-	if (indoms == nil) {
-		free(ndbgetvalue(db, &s, "sys", "inside-dom", "dom", &indoms));
-		free(ndbgetvalue(db, &s, "sys", "inside-ns", "ip", &innmsrvs));
-		free(ndbgetvalue(db, &s, "sys", "outside-ns", "ip", &outnmsrvs));
-		syslog(0, LOG, "reloaded inside-dom, inside-ns, outside-ns");
-	}
-}
-
-/*
- * is this domain (or DOMAIN or Domain or dOMAIN)
- * internal to our organisation (behind our firewall)?
- * only inside straddling servers care, everybody else gets told `yes',
- * so they'll use mntpt for their queries.
- */
-static int
-insideaddr(char *dom)
-{
-	int domlen, vallen, rv;
-	Ndbtuple *t;
-
-	if (!inside || !straddle || !serve)
-		return 1;
-
-	qlock(&ndblock);
-	if (indoms == nil) {
-		db = ndbopen(nil);
-		if (db != nil)
-			loaddomsrvs(db);
-		/* leave db open so we can quickly test for changes */
-	} else if (ndbchanged(db)) {
-		ndbfree(indoms);
-		ndbfree(innmsrvs);
-		ndbfree(outnmsrvs);
-		indoms = innmsrvs = outnmsrvs = nil;
-		ndbreopen(db);
-		loaddomsrvs(db);
-	}
-
-	if (indoms == nil) {
-		qunlock(&ndblock);
-		return 1;	/* no "inside" sys, try inside nameservers */
-	}
-
-	rv = 0;
-	domlen = strlen(dom);
-	for (t = indoms; t != nil; t = t->entry) {
-		if (strcmp(t->attr, "dom") != 0)
-			continue;
-		vallen = strlen(t->val);
-		if (cistrcmp(dom, t->val) == 0 ||
-		    domlen > vallen &&
-		     cistrcmp(dom + domlen - vallen, t->val) == 0 &&
-		     dom[domlen - vallen - 1] == '.') {
-			rv = 1;
-			break;
-		}
 	}
-	qunlock(&ndblock);
-	return rv;
-}
-
-static int
-insidens(uchar *ip)
-{
-	uchar ipa[IPaddrlen];
-	Ndbtuple *t;
-
-	for (t = innmsrvs; t != nil; t = t->entry)
-		if (strcmp(t->attr, "ip") == 0) {
-			parseip(ipa, t->val);
-			if (memcmp(ipa, ip, sizeof ipa) == 0)
-				return 1;
-		}
 	return 0;
 }
 
-static uchar *
-outsidens(void)
-{
-	Ndbtuple *t;
-	static uchar ipa[IPaddrlen];
-
-	for (t = outnmsrvs; t != nil; t = t->entry)
-		if (strcmp(t->attr, "ip") == 0) {
-			parseip(ipa, t->val);
-			return ipa;
-		}
-	return nil;
-}
-
 /*
  *  Get next server address
  */
 static int
-serveraddrs(DN *dp, RR *nsrp, Dest *dest, int nd, int depth, Request *reqp)
+serveraddrs(RR *nsrp, Dest *dest, int nd, int depth, Request *reqp)
 {
 	RR *rp, *arp, *trp;
 	Dest *cur;
@@ -617,7 +481,7 @@ serveraddrs(DN *dp, RR *nsrp, Dest *dest, int nd, int depth, Request *reqp)
 	 *  server addresses, try resolving one via the network.
 	 *  Mark any we try to resolve so we don't try a second time.
 	 */
-	if(arp == 0)
+	if(arp == 0){
 		for(rp = nsrp; rp; rp = rp->next){
 			if(rp->marker)
 				continue;
@@ -629,12 +493,12 @@ serveraddrs(DN *dp, RR *nsrp, Dest *dest, int nd, int depth, Request *reqp)
 			if(subsume(rp->owner->name, rp->host->name))
 				continue;
 
-			arp = dnresolve(rp->host->name, Cin, Ta, reqp, 0,
-				depth+1, Recurse, 1, 0);
+			arp = dnresolve(rp->host->name, Cin, Ta, reqp, 0, depth+1, Recurse, 1, 0);
 			rrfreelist(rrremneg(&arp));
 			if(arp)
 				break;
 		}
+	}
 
 	/* use any addresses that we found */
 	for(trp = arp; trp; trp = trp->next){
@@ -642,8 +506,7 @@ serveraddrs(DN *dp, RR *nsrp, Dest *dest, int nd, int depth, Request *reqp)
 			break;
 		cur = &dest[nd];
 		parseip(cur->a, trp->ip->name);
-		if (ipisbm(cur->a) ||
-		    !insideaddr(dp->name) && insidens(cur->a))
+		if(ipisbm(cur->a))
 			continue;
 		cur->nx = 0;
 		cur->s = trp->owner;
@@ -664,14 +527,14 @@ cacheneg(DN *dp, int type, int rcode, RR *soarr)
 	DN *soaowner;
 	ulong ttl;
 
-	/* no cache time specified, don't make anything up */
+	/* no cache time specified, don' make anything up */
 	if(soarr != nil){
 		if(soarr->next != nil){
 			rrfreelist(soarr->next);
 			soarr->next = nil;
 		}
 		soaowner = soarr->owner;
-	} else
+	} else 
 		soaowner = nil;
 
 	/* the attach can cause soarr to be freed so mine it now */
@@ -697,18 +560,16 @@ cacheneg(DN *dp, int type, int rcode, RR *soarr)
  *  name server, recurse.
  */
 static int
-netquery1(int fd, DN *dp, int type, RR *nsrp, Request *reqp, int depth,
-	uchar *ibuf, uchar *obuf, int waitsecs, int inns)
+netquery1(int fd, DN *dp, int type, RR *nsrp, Request *reqp, int depth, uchar *ibuf, uchar *obuf)
 {
 	int ndest, j, len, replywaits, rv;
-	ulong endtime;
 	ushort req;
-	char buf[12];
-	DN *ndp;
-	DNSmsg m;
+	RR *tp, *soarr;
 	Dest *p, *l, *np;
+	DN *ndp;
 	Dest dest[Maxdest];
-	RR *tp, *soarr;
+	DNSmsg m;
+	ulong endtime;
 
 	/* pack request into a message */
 	req = rand();
@@ -731,25 +592,13 @@ netquery1(int fd, DN *dp, int type, RR *nsrp, Request *reqp, int depth,
 
 		/* get a server address if we need one */
 		if(ndest > l - p){
-			j = serveraddrs(dp, nsrp, dest, l - p, depth, reqp);
+			j = serveraddrs(nsrp, dest, l - p, depth, reqp);
 			l = &dest[j];
 		}
 
 		/* no servers, punt */
 		if(l == dest)
-			if (straddle && inside) {
-				/* HACK: use sys=outside ips */
-				if (outsidens() == nil)
-					sysfatal("no outside-ns in ndb");
-				p = dest;
-				memmove(p->a, outsidens(), sizeof p->a);
-				p->s = dnlookup("outside", Cin, 1);
-				p->nx = p->code = 0;
-				l = p + 1;
-			} else {
-syslog(0, LOG, "netquery1: no servers for %s", dp->name);	// DEBUG
-				break;
-			}
+			break;
 
 		/* send to first 'ndest' destinations */
 		j = 0;
@@ -764,15 +613,10 @@ syslog(0, LOG, "netquery1: no servers for %s", dp->name);	// DEBUG
 			if((1<<p->nx) > ndest)
 				continue;
 
-			memmove(obuf, p->a, sizeof p->a);
-			procsetname("req slave: %sside query to %I/%s %s %s",
-				(inns? "in": "out"), obuf, p->s->name, dp->name,
-				rrname(type, buf, sizeof buf));
+			memmove(obuf, p->a, sizeof(p->a));
 			if(debug)
 				logsend(reqp->id, depth, obuf, p->s->name,
 					dp->name, type);
-
-			/* actually send the UDP packet */
 			if(write(fd, obuf, len + OUdphdrsize) < 0)
 				warning("sending udp msg %r");
 			p->nx++;
@@ -780,16 +624,12 @@ syslog(0, LOG, "netquery1: no servers for %s", dp->name);	// DEBUG
 		if(j == 0)
 			break;		/* no destinations left */
 
-		endtime = time(0) + waitsecs;
+		/* wait up to 5 seconds for replies */
+		endtime = time(0) + 5;
 		if(endtime > reqp->aborttime)
 			endtime = reqp->aborttime;
 
 		for(replywaits = 0; replywaits < ndest; replywaits++){
-			procsetname(
-			    "req slave: reading %sside reply from %I for %s %s",
-				(inns? "in": "out"), obuf, dp->name,
-				rrname(type, buf, sizeof buf));
-			memset(&m, 0, sizeof m);
 			if(readreply(fd, dp, type, req, ibuf, &m, endtime, reqp) < 0)
 				break;		/* timed out */
 
@@ -833,14 +673,14 @@ syslog(0, LOG, "netquery1: no servers for %s", dp->name);	// DEBUG
 
 			/* incorporate answers */
 			if(m.an)
-				rrattach(m.an, (m.flags & Fauth) != 0);
+				rrattach(m.an, (m.flags & Fauth) ? 1 : 0);
 			if(m.ar)
 				rrattach(m.ar, 0);
 			if(m.ns){
 				ndp = m.ns->owner;
 				rrattach(m.ns, 0);
 			} else
-				ndp = nil;
+				ndp = 0;
 
 			/* free the question */
 			if(m.qd)
@@ -852,16 +692,15 @@ syslog(0, LOG, "netquery1: no servers for %s", dp->name);	// DEBUG
 			 */
 			if(m.an != nil || (m.flags & Fauth)){
 				if(m.an == nil && (m.flags & Rmask) == Rname)
-					dp->respcode = Rname;
+					dp->nonexistent = Rname;
 				else
-					dp->respcode = 0;
+					dp->nonexistent = 0;
 
 				/*
 				 *  cache any negative responses, free soarr
 				 */
 				if((m.flags & Fauth) && m.an == nil)
-					cacheneg(dp, type, (m.flags & Rmask),
-						soarr);
+					cacheneg(dp, type, (m.flags & Rmask), soarr);
 				else
 					rrfreelist(soarr);
 				return 1;
@@ -869,22 +708,13 @@ syslog(0, LOG, "netquery1: no servers for %s", dp->name);	// DEBUG
 			rrfreelist(soarr);
 
 			/*
-			 *  if we've been given better name servers,
-			 *  recurse.  we're called from udpquery, called from
-			 *  netquery, which current holds dp->querylck,
-			 *  so release it now and acquire it upon return.
+			 *  if we've been given better name servers
+			 *  recurse
 			 */
 			if(m.ns){
 				tp = rrlookup(ndp, Tns, NOneg);
 				if(!contains(nsrp, tp)){
-					procsetname(
-					 "req slave: recursive query for %s %s",
-						dp->name,
-						rrname(type, buf, sizeof buf));
-					qunlock(&dp->querylck);
-					rv = netquery(dp, type, tp, reqp,
-						depth + 1);
-					qlock(&dp->querylck);
+					rv = netquery(dp, type, tp, reqp, depth+1);
 					rrfreelist(tp);
 					return rv;
 				} else
@@ -893,146 +723,44 @@ syslog(0, LOG, "netquery1: no servers for %s", dp->name);	// DEBUG
 		}
 	}
 
-	/* if all servers returned failure, propagate it */
-	dp->respcode = Rserver;
+	/* if all servers returned failure, propogate it */
+	dp->nonexistent = Rserver;
 	for(p = dest; p < l; p++)
 		if(p->code != Rserver)
-			dp->respcode = 0;
+			dp->nonexistent = 0;
 
 	return 0;
 }
 
-/*
- *  run a command with a supplied fd as standard input
- */
-char *
-system(int fd, char *cmd)
-{
-	int pid, p, i;
-	static Waitmsg msg;
-
-	if((pid = fork()) == -1)
-		sysfatal("fork failed: %r");
-	else if(pid == 0){
-		dup(fd, 0);
-		close(fd);
-		for (i = 3; i < 200; i++)
-			close(i);		/* don't leak fds */
-		execl("/bin/rc", "rc", "-c", cmd, nil);
-		sysfatal("exec rc: %r");
-	}
-	for(p = waitpid(); p >= 0; p = waitpid())
-		if(p == pid)
-			return msg.msg;	
-	return "lost child";
-}
-
-enum { Hurry, Patient, };
-enum { Outns, Inns, };
-
-static int
-udpquery(char *mntpt, DN *dp, int type, RR *nsrp, Request *reqp, int depth,
-	int patient, int inns)
-{
-	int fd, rv = 0;
-	char *msg;
-	uchar *obuf, *ibuf;
-
-	/* use alloced buffers rather than ones from the stack */
-	ibuf = emalloc(Maxudpin+OUdphdrsize);
-	obuf = emalloc(Maxudp+OUdphdrsize);
-
-	fd = udpport(mntpt);
-	if (fd < 0 && straddle && strcmp(mntpt, "/net.alt") == 0) {
-		/* HACK: remount /net.alt */
-		syslog(0, LOG, "remounting /net.alt");
-		unmount(nil, "/net.alt");
-		msg = system(open("/dev/null", ORDWR), "outside");
-		if (msg && *msg) {
-			syslog(0, LOG, "can't remount /net.alt: %s", msg);
-			sleep(2000);		/* don't spin wildly */
-		} else
-			fd = udpport(mntpt);
-	}
-	if(fd >= 0) {
-		reqp->aborttime = time(0) + (patient? Maxreqtm: Maxreqtm/2);
-		rv = netquery1(fd, dp, type, nsrp, reqp, depth,
-			ibuf, obuf, (patient? 15: 10), inns);
-		close(fd);
-	}
-
-	free(obuf);
-	free(ibuf);
-	return rv;
-}
-
-/* look up (dp->name,type) via *nsrp with results in *reqp */
 static int
 netquery(DN *dp, int type, RR *nsrp, Request *reqp, int depth)
 {
-	int lock, rv, triedin;
+	uchar *obuf;
+	uchar *ibuf;
 	RR *rp;
+	int fd, rv;
 
-	if(depth > 12)			/* in a recursive loop? */
+	if(depth > 12)
 		return 0;
 
-	slave(reqp);			/* might fork */
-	/* if so, parent process longjmped to req->mret; we're child slave */
-	if (!reqp->isslave)
-		syslog(0, LOG,
-			"[%d] netquery: slave returned with reqp->isslave==0",
-			getpid());
-
-	/* don't lock before call to slave so only children can block */
-	lock = reqp->isslave != 0;
-	if(lock) {
-		procsetname("waiting for query lock on %s", dp->name);
-		/* don't make concurrent queries for this name */
-		qlock(&dp->querylck);
-		procsetname("netquery: %s", dp->name);
-	}
+	/* use alloced buffers rather than ones from the stack */
+	ibuf = emalloc(Maxudpin+OUdphdrsize);
+	obuf = emalloc(Maxudp+OUdphdrsize);
+
+	slave(reqp);
 
 	/* prepare server RR's for incremental lookup */
 	for(rp = nsrp; rp; rp = rp->next)
 		rp->marker = 0;
 
-	rv = 0;				/* pessimism */
-	triedin = 0;
-	/*
-	 * normal resolvers and servers will just use mntpt for all addresses,
-	 * even on the outside.  straddling servers will use mntpt (/net)
-	 * for inside addresses and /net.alt for outside addresses,
-	 * thus bypassing other inside nameservers.
-	 */
-	if (!straddle || insideaddr(dp->name)) {
-		rv = udpquery(mntpt, dp, type, nsrp, reqp, depth, Hurry,
-			(inside? Inns: Outns));
-		triedin = 1;
-	}
-
-	/*
-	 * if we're still looking, are inside, and have an outside domain,
-	 * try it on our outside interface, if any.
-	 */
-	if (rv == 0 && inside && !insideaddr(dp->name)) {
-		if (triedin)
-			syslog(0, LOG,
-	   "[%d] netquery: internal nameservers failed for %s; trying external",
-				getpid(), dp->name);
-
-		/* prepare server RR's for incremental lookup */
-		for(rp = nsrp; rp; rp = rp->next)
-			rp->marker = 0;
-
-		rv = udpquery("/net.alt", dp, type, nsrp, reqp, depth, Patient,
-			Outns);
-		if (rv == 0)
-			syslog(0, LOG, "[%d] netquery: no luck for %s",
-				getpid(), dp->name);
-	}
-
-	if(lock)
-		qunlock(&dp->querylck);
+	fd = udpport();
+	if(fd < 0)
+		rv = 0;
+	else
+		rv = netquery1(fd, dp, type, nsrp, reqp, depth, ibuf, obuf);
+	close(fd);
+	free(ibuf);
+	free(obuf);
 
 	return rv;
 }

sys/src/cmd/ndb/dns.c

@@ -11,12 +11,12 @@
 enum
 {
 	Maxrequest=		1024,
+	Ncache=			8,
+	Maxpath=		128,
 	Maxreply=		512,
 	Maxrrr=			16,
 	Maxfdata=		8192,
 
-	Defmaxage=		60*60,		/* 1 hour */
-
 	Qdir=			0,
 	Qdns=			1,
 };
@@ -42,9 +42,9 @@ struct Mfile
 	ushort		nrr;		/* number of rr's */
 };
 
-/*
- *  active local requests
- */
+//
+//  active local requests
+//
 struct Job
 {
 	Job	*next;
@@ -60,86 +60,81 @@ struct {
 	Mfile	*inuse;		/* active mfile's */
 } mfalloc;
 
-extern int inside, straddle, serve;
-
-int	cachedb;
-int	debug;
-uchar	ipaddr[IPaddrlen];	/* my ip address */
-int	maxage = Defmaxage;
 int	mfd[2];
-int	needrefresh;
+int	debug;
+int traceactivity;
+int	cachedb;
 ulong	now;
-int	resolver;
-int	sendnotifies;
 int	testing;
 char	*trace;
-int	traceactivity;
+int	needrefresh;
+int	resolver;
+uchar	ipaddr[IPaddrlen];	/* my ip address */
+int	maxage;
 char	*zonerefreshprogram;
+int	sendnotifies;
 
-char	*LOG;
-char	*dbfile;
-char	*logfile = "dns";
-char	mntpt[Maxpath];
-
-int	fillreply(Mfile*, int);
-void	freejob(Job*);
-void	io(void);
-void	mountinit(char*, char*);
-Job*	newjob(void);
-void	rattach(Job*, Mfile*);
+void	rversion(Job*);
 void	rauth(Job*);
-void	rclunk(Job*, Mfile*);
-void	rcreate(Job*, Mfile*);
 void	rflush(Job*);
+void	rattach(Job*, Mfile*);
+char*	rwalk(Job*, Mfile*);
 void	ropen(Job*, Mfile*);
+void	rcreate(Job*, Mfile*);
 void	rread(Job*, Mfile*);
+void	rwrite(Job*, Mfile*, Request*);
+void	rclunk(Job*, Mfile*);
 void	rremove(Job*, Mfile*);
 void	rstat(Job*, Mfile*);
-void	rversion(Job*);
-char*	rwalk(Job*, Mfile*);
-void	rwrite(Job*, Mfile*, Request*);
 void	rwstat(Job*, Mfile*);
 void	sendmsg(Job*, char*);
+void	mountinit(char*, char*);
+void	io(void);
+int	fillreply(Mfile*, int);
+Job*	newjob(void);
+void	freejob(Job*);
 void	setext(char*, int, char*);
 
+char	*logfile = "dns";
+char	*dbfile;
+char	mntpt[Maxpath];
+char	*LOG;
+
 void
 usage(void)
 {
-	fprint(2, "usage: %s [-norRst] [-a maxage] [-f ndb-file] [-N target] "
-		"[-x netmtpt] [-z refreshprog]\n", argv0);
+	fprint(2, "usage: %s [-rRs] [-f ndb-file] [-x netmtpt]\n", argv0);
 	exits("usage");
 }
 
 void
 main(int argc, char *argv[])
 {
-	char	servefile[Maxpath], ext[Maxpath];
+	int	serve;
+	char	servefile[Maxpath];
+	char	ext[Maxpath];
+	char	*p;
 
-	setnetmtpt(mntpt, sizeof mntpt, nil);
+	serve = 0;
+	setnetmtpt(mntpt, sizeof(mntpt), nil);
 	ext[0] = 0;
 	ARGBEGIN{
-	case 'a':
-		maxage = atol(EARGF(usage()));
-		if (maxage <= 0)
-			maxage = Defmaxage;
-		break;
 	case 'd':
 		debug = 1;
 		traceactivity = 1;
 		break;
 	case 'f':
-		dbfile = EARGF(usage());
-		break;
-	case 'n':
-		sendnotifies = 1;
+		p = ARGF();
+		if(p == nil)
+			usage();
+		dbfile = p;
 		break;
-	case 'N':
-		target = atol(EARGF(usage()));
-		if (target < 100)
-			target = 100;
-		break;
-	case 'o':
-		straddle = 1;		/* straddle inside & outside networks */
+	case 'x':
+		p = ARGF();
+		if(p == nil)
+			usage();
+		setnetmtpt(mntpt, sizeof(mntpt), p);
+		setext(ext, sizeof(ext), mntpt);
 		break;
 	case 'r':
 		resolver = 1;
@@ -148,42 +143,42 @@ main(int argc, char *argv[])
 		norecursion = 1;
 		break;
 	case 's':
-		serve = 1;		/* serve network */
+		serve = 1;	/* serve network */
 		cachedb = 1;
 		break;
+	case 'a':
+		p = ARGF();
+		if(p == nil)
+			usage();
+		maxage = atoi(p);
+		break;
 	case 't':
 		testing = 1;
 		break;
-	case 'x':
-		setnetmtpt(mntpt, sizeof mntpt, EARGF(usage()));
-		setext(ext, sizeof ext, mntpt);
-		break;
 	case 'z':
-		zonerefreshprogram = EARGF(usage());
+		zonerefreshprogram = ARGF();
+		break;
+	case 'n':
+		sendnotifies = 1;
 		break;
 	}ARGEND
 	USED(argc);
 	USED(argv);
 
-	if(testing)
-		mainmem->flags |= POOL_NOREUSE;
-//	mainmem->flags |= POOL_ANTAGONISM | POOL_PARANOIA;	/* DEBUG */
+if(testing) mainmem->flags |= POOL_NOREUSE;
 	rfork(RFREND|RFNOTEG);
 
-	inside = (*mntpt == '\0' || strcmp(mntpt, "/net") == 0);
-
 	/* start syslog before we fork */
 	fmtinstall('F', fcallfmt);
 	dninit();
 	if(myipaddr(ipaddr, mntpt) < 0)
 		sysfatal("can't read my ip address");
 
-	syslog(0, logfile, "starting %sdns on %I's %s",
-		(straddle? "straddling ": ""), ipaddr, mntpt);
+	syslog(0, logfile, "starting dns on %I", ipaddr);
 
 	opendatabase();
 
-	snprint(servefile, sizeof servefile, "#s/dns%s", ext);
+	snprint(servefile, sizeof(servefile), "#s/dns%s", ext);
 	unmount(servefile, mntpt);
 	remove(servefile);
 	mountinit(servefile, mntpt);
@@ -203,7 +198,7 @@ main(int argc, char *argv[])
 }
 
 /*
- *  if a mount point is specified, set the cs extension to be the mount point
+ *  if a mount point is specified, set the cs extention to be the mount point
  *  with '_'s replacing '/'s
  */
 void
@@ -235,7 +230,6 @@ mountinit(char *service, char *mntpt)
 	switch(rfork(RFFDG|RFPROC|RFNAMEG)){
 	case 0:
 		close(p[1]);
-		procsetname("main");
 		break;
 	case -1:
 		abort(); /* "fork failed\n" */;
@@ -269,13 +263,14 @@ newfid(int fid, int needunused)
 	Mfile *mf;
 
 	lock(&mfalloc);
-	for(mf = mfalloc.inuse; mf != nil; mf = mf->next)
+	for(mf = mfalloc.inuse; mf != nil; mf = mf->next){
 		if(mf->fid == fid){
 			unlock(&mfalloc);
 			if(needunused)
 				return nil;
 			return mf;
 		}
+	}
 	mf = emalloc(sizeof(*mf));
 	if(mf == nil)
 		sysfatal("out of memory");
@@ -292,18 +287,16 @@ freefid(Mfile *mf)
 	Mfile **l;
 
 	lock(&mfalloc);
-	for(l = &mfalloc.inuse; *l != nil; l = &(*l)->next)
+	for(l = &mfalloc.inuse; *l != nil; l = &(*l)->next){
 		if(*l == mf){
 			*l = mf->next;
-			if(mf->user) {
-				memset(mf->user, 0, sizeof *mf->user); /* cause trouble */
+			if(mf->user)
 				free(mf->user);
-			}
-			memset(mf, 0, sizeof *mf);	/* cause trouble */
 			free(mf);
 			unlock(&mfalloc);
 			return;
 		}
+	}
 	sysfatal("freeing unused fid");
 }
 
@@ -343,13 +336,13 @@ freejob(Job *job)
 	Job **l;
 
 	lock(&joblock);
-	for(l = &joblist; *l; l = &(*l)->next)
+	for(l = &joblist; *l; l = &(*l)->next){
 		if((*l) == job){
 			*l = job->next;
-			memset(job, 0, sizeof *job);	/* cause trouble */
 			free(job);
 			break;
 		}
+	}
 	unlock(&joblock);
 }
 
@@ -359,11 +352,12 @@ flushjob(int tag)
 	Job *job;
 
 	lock(&joblock);
-	for(job = joblist; job; job = job->next)
+	for(job = joblist; job; job = job->next){
 		if(job->request.tag == tag && job->request.type != Tflush){
 			job->flushed = 1;
 			break;
 		}
+	}
 	unlock(&joblock);
 }
 
@@ -376,7 +370,6 @@ io(void)
 	Request req;
 	Job *job;
 
-	memset(&req, 0, sizeof req);
 	/*
 	 *  a slave process is sometimes forked to wait for replies from other
 	 *  servers.  The master process returns immediately via a longjmp
@@ -384,7 +377,6 @@ io(void)
 	 */
 	if(setjmp(req.mret))
 		putactivity(0);
-	procsetname("main 9p reading loop");
 	req.isslave = 0;
 	for(;;){
 		n = read9pmsg(mfd[0], mdata, sizeof mdata);
@@ -392,7 +384,6 @@ io(void)
 			syslog(0, logfile, "error reading mntpt: %r");
 			exits(0);
 		}
-
 		job = newjob();
 		if(convM2S(mdata, n, &job->request) != n){
 			freejob(job);
@@ -403,12 +394,11 @@ io(void)
 			syslog(0, logfile, "%F", &job->request);
 
 		getactivity(&req, 0);
-		req.aborttime = now + Maxreqtm;
+		req.aborttime = now + 60;	/* don't spend more than 60 seconds */
 
 		switch(job->request.type){
 		default:
-			syslog(1, logfile, "unknown request type %d",
-				job->request.type);
+			syslog(1, logfile, "unknown request type %d", job->request.type);
 			break;
 		case Tversion:
 			rversion(job);
@@ -452,7 +442,7 @@ io(void)
 		}
 
 		freejob(job);
-
+	
 		/*
 		 *  slave processes die after replying
 		 */
@@ -460,7 +450,7 @@ io(void)
 			putactivity(0);
 			_exits(0);
 		}
-
+	
 		putactivity(0);
 	}
 }
@@ -512,15 +502,16 @@ rattach(Job *job, Mfile *mf)
 char*
 rwalk(Job *job, Mfile *mf)
 {
-	int i, nelems;
 	char *err;
 	char **elems;
+	int nelems;
+	int i;
 	Mfile *nmf;
 	Qid qid;
 
 	err = 0;
 	nmf = nil;
-	elems  = job->request.wname;
+	elems = job->request.wname;
 	nelems = job->request.nwname;
 	job->reply.nwqid = 0;
 
@@ -543,11 +534,10 @@ rwalk(Job *job, Mfile *mf)
 				err = "not a directory";
 				break;
 			}
-			if (strcmp(elems[i], "..") == 0 ||
-			    strcmp(elems[i], ".") == 0){
+			if(strcmp(elems[i], "..") == 0 || strcmp(elems[i], ".") == 0){
 				qid.type = QTDIR;
 				qid.path = Qdir;
-Found:
+    Found:
 				job->reply.wqid[i] = qid;
 				job->reply.nwqid++;
 				continue;
@@ -562,7 +552,7 @@ Found:
 		}
 	}
 
-send:
+    send:
 	if(nmf != nil && (err!=nil || job->reply.nwqid<nelems))
 		freefid(nmf);
 	if(err == nil)
@@ -598,20 +588,17 @@ rcreate(Job *job, Mfile *mf)
 void
 rread(Job *job, Mfile *mf)
 {
-	int i, n;
-	long clock;
-	ulong cnt;
-	vlong off;
-	char *err;
-	uchar buf[Maxfdata];
+	int i, n, cnt;
+	long off;
 	Dir dir;
+	uchar buf[Maxfdata];
+	char *err;
+	long clock;
 
 	n = 0;
-	err = nil;
+	err = 0;
 	off = job->request.offset;
 	cnt = job->request.count;
-	*buf = '\0';
-	job->reply.data = (char*)buf;
 	if(mf->qid.type & QTDIR){
 		clock = time(0);
 		if(off == 0){
@@ -621,26 +608,27 @@ rread(Job *job, Mfile *mf)
 			dir.qid.path = Qdns;
 			dir.mode = 0666;
 			dir.length = 0;
-			dir.uid = dir.gid = dir.muid = mf->user;
-			dir.atime = dir.mtime = clock;		/* wrong */
+			dir.uid = mf->user;
+			dir.gid = mf->user;
+			dir.muid = mf->user;
+			dir.atime = clock;	/* wrong */
+			dir.mtime = clock;	/* wrong */
 			n = convD2M(&dir, buf, sizeof buf);
 		}
-	} else if (off < 0)
-		err = "negative read offset";
-	else {
-		/* first offset will always be zero */
+		job->reply.data = (char*)buf;
+	} else {
 		for(i = 1; i <= mf->nrr; i++)
 			if(mf->rr[i] > off)
 				break;
-		if(i <= mf->nrr) {
-			if(off + cnt > mf->rr[i])
-				n = mf->rr[i] - off;
-			else
-				n = cnt;
-			assert(n >= 0);
-			job->reply.data = mf->reply + off;
-		}
+		if(i > mf->nrr)
+			goto send;
+		if(off + cnt > mf->rr[i])
+			n = mf->rr[i] - off;
+		else
+			n = cnt;
+		job->reply.data = mf->reply + off;
 	}
+send:
 	job->reply.count = n;
 	sendmsg(job, err);
 }
@@ -648,22 +636,18 @@ rread(Job *job, Mfile *mf)
 void
 rwrite(Job *job, Mfile *mf, Request *req)
 {
-	int rooted, status, wantsav;
+	int cnt, rooted, status;
 	long n;
-	ulong cnt;
 	char *err, *p, *atype;
 	RR *rp, *tp, *neg;
+	int wantsav;
 
-	err = nil;
+	err = 0;
 	cnt = job->request.count;
 	if(mf->qid.type & QTDIR){
 		err = "can't write directory";
 		goto send;
 	}
-	if (job->request.offset != 0) {
-		err = "writing at non-zero offset";
-		goto send;
-	}
 	if(cnt >= Maxrequest){
 		err = "request too long";
 		goto send;
@@ -675,16 +659,16 @@ rwrite(Job *job, Mfile *mf, Request *req)
 	/*
 	 *  special commands
 	 */
-	if(strcmp(job->request.data, "debug")==0){
+	if(strncmp(job->request.data, "debug", 5)==0 && job->request.data[5] == 0){
 		debug ^= 1;
 		goto send;
-	} else if(strcmp(job->request.data, "dump")==0){
+	} else if(strncmp(job->request.data, "dump", 4)==0 && job->request.data[4] == 0){
 		dndump("/lib/ndb/dnsdump");
 		goto send;
-	} else if(strcmp(job->request.data, "refresh")==0){
+	} else if(strncmp(job->request.data, "refresh", 7)==0 && job->request.data[7] == 0){
 		needrefresh = 1;
 		goto send;
-	} else if(strcmp(job->request.data, "poolcheck")==0){
+	} else if(strncmp(job->request.data, "poolcheck", 9)==0 && job->request.data[9] == 0){
 		poolcheck(mainmem);
 		goto send;
 	}
@@ -718,7 +702,6 @@ rwrite(Job *job, Mfile *mf, Request *req)
 		goto send;
 	}
 
-	/* normal request: domain [type] */
 	mf->type = rrtype(atype);
 	if(mf->type < 0){
 		err = "unknown type";
@@ -738,18 +721,15 @@ rwrite(Job *job, Mfile *mf, Request *req)
 		p++;
 	} else
 		wantsav = 0;
-
 	dncheck(0, 1);
 	rp = dnresolve(p, Cin, mf->type, req, 0, 0, Recurse, rooted, &status);
-
 	dncheck(0, 1);
 	neg = rrremneg(&rp);
 	if(neg){
 		status = neg->negrcode;
 		rrfreelist(neg);
 	}
-
-	if(rp == nil)
+	if(rp == 0){
 		switch(status){
 		case Rname:
 			err = "name does not exist";
@@ -761,28 +741,27 @@ rwrite(Job *job, Mfile *mf, Request *req)
 			err = "resource does not exist";
 			break;
 		}
-	else {
+	} else {
 		lock(&joblock);
 		if(!job->flushed){
 			/* format data to be read later */
 			n = 0;
 			mf->nrr = 0;
 			for(tp = rp; mf->nrr < Maxrrr-1 && n < Maxreply && tp &&
-			    tsame(mf->type, tp->type); tp = tp->next){
+					tsame(mf->type, tp->type); tp = tp->next){
 				mf->rr[mf->nrr++] = n;
 				if(wantsav)
-					n += snprint(mf->reply+n, Maxreply-n,
-						"%Q", tp);
+					n += snprint(mf->reply+n, Maxreply-n, "%Q", tp);
 				else
-					n += snprint(mf->reply+n, Maxreply-n,
-						"%R", tp);
+					n += snprint(mf->reply+n, Maxreply-n, "%R", tp);
 			}
 			mf->rr[mf->nrr] = n;
 		}
 		unlock(&joblock);
 		rrfreelist(rp);
 	}
-send:
+
+    send:
 	dncheck(0, 1);
 	job->reply.count = cnt;
 	sendmsg(job, err);
@@ -817,7 +796,9 @@ rstat(Job *job, Mfile *mf)
 	}
 	dir.qid = mf->qid;
 	dir.length = 0;
-	dir.uid = dir.gid = dir.muid = mf->user;
+	dir.uid = mf->user;
+	dir.gid = mf->user;
+	dir.muid = mf->user;
 	dir.atime = dir.mtime = time(0);
 	job->reply.nstat = convD2M(&dir, buf, sizeof buf);
 	job->reply.stat = buf;
@@ -842,13 +823,13 @@ sendmsg(Job *job, char *err)
 		job->reply.type = Rerror;
 		snprint(ename, sizeof(ename), "dns: %s", err);
 		job->reply.ename = ename;
-	}else
+	}else{
 		job->reply.type = job->request.type+1;
+	}
 	job->reply.tag = job->request.tag;
 	n = convS2M(&job->reply, mdata, sizeof mdata);
 	if(n == 0){
-		syslog(1, logfile, "sendmsg convS2M of %F returns 0",
-			&job->reply);
+		syslog(1, logfile, "sendmsg convS2M of %F returns 0", &job->reply);
 		abort();
 	}
 	lock(&joblock);
@@ -891,8 +872,7 @@ logsend(int id, int subid, uchar *addr, char *sname, char *rname, int type)
 	char buf[12];
 
 	syslog(0, LOG, "[%d] %d.%d: sending to %I/%s %s %s",
-		getpid(), id, subid, addr, sname, rname,
-		rrname(type, buf, sizeof buf));
+		getpid(), id, subid, addr, sname, rname, rrname(type, buf, sizeof buf));
 }
 
 RR*

sys/src/cmd/ndb/dns.h

@@ -3,7 +3,7 @@ typedef struct Ndbtuple Ndbtuple;
 enum
 {
 	/* RR types; see: http://www.iana.org/assignments/dns-parameters */
-	Ta=		1,
+	Ta=			1,
 	Tns=		2,
 	Tmd=		3,
 	Tmf=		4,
@@ -63,7 +63,7 @@ enum
 	Ttsig=	250,	/* transaction signature */
 	Tixfr=	251,	/* incremental zone transfer */
 	Taxfr=	252,	/* zone transfer */
-	Tmailb=	253,	/* { Tmb, Tmg, Tmr } */
+	Tmailb=	253,	/* { Tmb, Tmg, Tmr } */	
 	Tmaila= 254,	/* obsolete */
 	Tall=	255,	/* all records */
 
@@ -137,29 +137,24 @@ enum
 	/* length of domain name hash table */
 	HTLEN= 		4*1024,
 
-	Maxpath=	128,	/* size of mntpt */
-
 	RRmagic=	0xdeadbabe,
 	DNmagic=	0xa110a110,
 
 	/* parallelism */
 	Maxactive=	32,
-
-	Maxreqtm=	60,	/* max. seconds to process a request */
 };
 
-typedef struct Area	Area;
-typedef struct Block	Block;
-typedef struct Cert	Cert;
 typedef struct DN	DN;
 typedef struct DNSmsg	DNSmsg;
-typedef struct Key	Key;
-typedef struct Null	Null;
 typedef struct RR	RR;
-typedef struct Request	Request;
 typedef struct SOA	SOA;
-typedef struct Server	Server;
+typedef struct Area	Area;
+typedef struct Request	Request;
+typedef struct Key	Key;
+typedef struct Cert	Cert;
 typedef struct Sig	Sig;
+typedef struct Null	Null;
+typedef struct Server	Server;
 typedef struct Txt	Txt;
 
 /*
@@ -186,46 +181,46 @@ struct DN
 	ulong	lookuptime;	/* last time we tried to get a better value */
 	ushort	class;		/* RR class */
 	char	refs;		/* for mark and sweep */
-	uchar	respcode;	/* response code */
-/* was:	char	nonexistent; /* true if we get an authoritative nx for this domain */
+	char	nonexistent;	/* true if we get an authoritative nx for this domain */
 	ulong	ordinal;
-	QLock	querylck;	/* permit only 1 query per domain name at a time */
 };
 
 /*
  *  security info
  */
-struct Block
-{
-	int	dlen;
-	uchar	*data;
-};
 struct Key
 {
 	int	flags;
 	int	proto;
 	int	alg;
-	Block;
+	int	dlen;
+	uchar	*data;
 };
 struct Cert
 {
 	int	type;
 	int	tag;
 	int	alg;
-	Block;
+	int	dlen;
+	uchar	*data;
 };
 struct Sig
 {
-	Cert;
+	int	type;
+	int	alg;
 	int	labels;
 	ulong	ttl;
 	ulong	exp;
 	ulong	incep;
+	int	tag;
 	DN	*signer;
+	int	dlen;
+	uchar	*data;
 };
 struct Null
 {
-	Block;
+	int	dlen;
+	uchar	*data;
 };
 
 /*
@@ -245,28 +240,28 @@ struct RR
 	RR	*next;
 	ulong	magic;
 	DN	*owner;		/* domain that owns this resource record */
+	uchar	negative;	/* this is a cached negative response */
 	uintptr	pc;
 	ulong	ttl;		/* time to live to be passed on */
 	ulong	expire;		/* time this entry expires locally */
-	ulong	marker;		/* used locally when scanning rrlists */
 	ushort	type;		/* RR type */
-	ushort	query;		/* query type is in response to */
-	uchar	auth;		/* flag: authoritative */
-	uchar	db;		/* flag: from database */
-	uchar	cached;		/* flag: rr in cache */
-	uchar	negative;	/* flag: this is a cached negative response */
-
-	union {			/* discriminated how? negative & type? */
+	ushort	query;		/* query tyis is in response to */
+	uchar	auth;		/* authoritative */
+	uchar	db;		/* from database */
+	uchar	cached;		/* rr in cache */
+	ulong	marker;		/* used locally when scanning rrlists */
+	union {
 		DN	*negsoaowner;	/* soa for cached negative response */
 		DN	*host;	/* hostname - soa, cname, mb, md, mf, mx, ns */
 		DN	*cpu;	/* cpu type - hinfo */
 		DN	*mb;	/* mailbox - mg, minfo */
-		DN	*ip;	/* ip address - a */
+		DN	*ip;	/* ip addrss - a */
 		DN	*rp;	/* rp arg - rp */
+		int	cruftlen;
 		ulong	arg0;
 	};
-	union {			/* discriminated how? negative & type? */
-		int	negrcode; /* response code for cached negative response */
+	union {
+		int	negrcode;	/* response code for cached negative response */
 		DN	*rmb;	/* responsible maibox - minfo, soa, rp */
 		DN	*ptr;	/* pointer to domain name - ptr */
 		DN	*os;	/* operating system - hinfo */
@@ -274,7 +269,7 @@ struct RR
 		ulong	local;	/* ns served from local database - ns */
 		ulong	arg1;
 	};
-	union {			/* discriminated by type */
+	union {
 		SOA	*soa;	/* soa timers - soa */
 		Key	*key;
 		Cert	*cert;
@@ -294,16 +289,15 @@ struct Server
 };
 
 /*
- *  timers for a start of authenticated record.  all ulongs are in seconds.
+ *  timers for a start of authenticated record
  */
 struct SOA
 {
-	ulong	serial;		/* zone serial # */
-	ulong	refresh;	/* zone refresh interval */
-	ulong	retry;		/* zone retry interval */
-	ulong	expire;		/* time to expiration */
-	ulong	minttl;		/* min. time to live for any entry */
-
+	ulong	serial;		/* zone serial # (sec) - soa */
+	ulong	refresh;	/* zone refresh interval (sec) - soa */
+	ulong	retry;		/* zone retry interval (sec) - soa */
+	ulong	expire;		/* time to expiration (sec) - soa */
+	ulong	minttl;		/* minimum time to live for any entry (sec) - soa */
 	Server	*slaves;	/* slave servers */
 };
 
@@ -329,12 +323,12 @@ struct DNSmsg
  */
 struct Area
 {
-	Area	*next;
+	Area		*next;
 
-	int	len;		/* strlen(area->soarr->owner->name) */
-	RR	*soarr;		/* soa defining this area */
-	int	neednotify;
-	int	needrefresh;
+	int		len;		/* strlen(area->soarr->owner->name) */
+	RR		*soarr;		/* soa defining this area */
+	int		neednotify;
+	int		needrefresh;
 };
 
 enum
@@ -345,114 +339,114 @@ enum
 	OKneg,
 };
 
-extern int	cachedb;
-extern char	*dbfile;
-extern int	debug;
-extern Area	*delegated;
-extern char	*logfile;
-extern int	maxage;		/* age of oldest entry in cache (secs) */
-extern char	mntpt[];
-extern int	needrefresh;
-extern int	norecursion;
-extern ulong	now;		/* time base */
-extern Area	*owned;
-extern int	resolver;
-extern int	sendnotifies;
-extern ulong	target;
-extern int	testing;	/* test cache whenever removing a DN */
-extern char	*trace;
-extern int	traceactivity;
-extern char	*zonerefreshprogram;
-
-#pragma	varargck	type	"R"	RR*
-#pragma	varargck	type	"Q"	RR*
-
-
 /* dn.c */
 extern char	*rrtname[];
 extern char	*rname[];
-extern unsigned	nrname;
 extern char	*opname[];
-
-void	db2cache(int);
-void	dninit(void);
-DN*	dnlookup(char*, int, int);
-void	dnage(DN*);
-void	dnageall(int);
-void	dnagedb(void);
-void	dnauthdb(void);
-void	dnget(void);
-void	dnpurge(void);
-void	dnput(void);
-Area*	inmyarea(char*);
-void	rrattach(RR*, int);
-RR*	rralloc(int);
-void	rrfree(RR*);
-void	rrfreelist(RR*);
-RR*	rrlookup(DN*, int, int);
-RR*	rrcat(RR**, RR*);
-RR**	rrcopy(RR*, RR**);
-RR*	rrremneg(RR**);
-RR*	rrremtype(RR**, int);
-int	rrfmt(Fmt*);
-int	rravfmt(Fmt*);
-int	rrsupported(int);
-int	rrtype(char*);
-char*	rrname(int, char*, int);
-int	tsame(int, int);
-void	dndump(char*);
-int	getactivity(Request*, int);
-void	putactivity(int);
-void	abort(); /* char*, ... */;
-void	warning(char*, ...);
-void	slave(Request*);
-void	dncheck(void*, int);
-void	unique(RR*);
-int	subsume(char*, char*);
-RR*	randomize(RR*);
-void*	emalloc(int);
-char*	estrdup(char*);
-void	dnptr(uchar*, uchar*, char*, int, int);
-void	addserver(Server**, char*);
-Server*	copyserverlist(Server*);
-void	freeserverlist(Server*);
+extern void	db2cache(int);
+extern void	dninit(void);
+extern DN*	dnlookup(char*, int, int);
+extern void	dnage(DN*);
+extern void	dnageall(int);
+extern void	dnagedb(void);
+extern void	dnauthdb(void);
+extern void	dnget(void);
+extern void	dnpurge(void);
+extern void	dnput(void);
+extern Area*	inmyarea(char*);
+extern void	rrattach(RR*, int);
+extern RR*	rralloc(int);
+extern void	rrfree(RR*);
+extern void	rrfreelist(RR*);
+extern RR*	rrlookup(DN*, int, int);
+extern RR*	rrcat(RR**, RR*);
+extern RR**	rrcopy(RR*, RR**);
+extern RR*	rrremneg(RR**);
+extern RR*	rrremtype(RR**, int);
+extern int	rrfmt(Fmt*);
+extern int	rravfmt(Fmt*);
+extern int	rrsupported(int);
+extern int	rrtype(char*);
+extern char*	rrname(int, char*, int);
+extern int	tsame(int, int);
+extern void	dndump(char*);
+extern int	getactivity(Request*, int);
+extern void	putactivity(int);
+extern void	abort(); /* char*, ... */;
+extern void	warning(char*, ...);
+extern void	slave(Request*);
+extern void	dncheck(void*, int);
+extern void	unique(RR*);
+extern int	subsume(char*, char*);
+extern RR*	randomize(RR*);
+extern void*	emalloc(int);
+extern char*	estrdup(char*);
+extern void	dnptr(uchar*, uchar*, char*, int, int);
+extern void	addserver(Server**, char*);
+extern Server*	copyserverlist(Server*);
+extern void	freeserverlist(Server*);
 
 /* dnarea.c */
-void	refresh_areas(Area*);
-void	freearea(Area**);
-void	addarea(DN *dp, RR *rp, Ndbtuple *t);
+extern void	refresh_areas(Area*);
+extern void	freearea(Area**);
+extern void	addarea(DN *dp, RR *rp, Ndbtuple *t);
 
 /* dblookup.c */
-RR*	dblookup(char*, int, int, int, int);
-RR*	dbinaddr(DN*, int);
-int	baddelegation(RR*, RR*, uchar*);
-RR*	dnsservers(int);
-RR*	domainlist(int);
-int	opendatabase(void);
+extern RR*	dblookup(char*, int, int, int, int);
+extern RR*	dbinaddr(DN*, int);
+extern int	baddelegation(RR*, RR*, uchar*);
+extern RR*	dnsservers(int);
+extern RR*	domainlist(int);
+extern int	opendatabase(void);
 
 /* dns.c */
-char*	walkup(char*);
-RR*	getdnsservers(int);
-void	logreply(int, uchar*, DNSmsg*);
-void	logsend(int, int, uchar*, char*, char*, int);
-void	procsetname(char *fmt, ...);
+extern char*	walkup(char*);
+extern RR*	getdnsservers(int);
+extern void	logreply(int, uchar*, DNSmsg*);
+extern void	logsend(int, int, uchar*, char*, char*, int);
 
 /* dnresolve.c */
-RR*	dnresolve(char*, int, int, Request*, RR**, int, int, int, int*);
-int	udpport(char *);
-int	mkreq(DN *dp, int type, uchar *buf, int flags, ushort reqno);
+extern RR*	dnresolve(char*, int, int, Request*, RR**, int, int, int, int*);
+extern int	udpport(void);
+extern int	mkreq(DN *dp, int type, uchar *buf, int flags, ushort reqno);
 
 /* dnserver.c */
-void	dnserver(DNSmsg*, DNSmsg*, Request*, uchar *, int);
-void	dnudpserver(char*);
-void	dntcpserver(char*);
+extern void	dnserver(DNSmsg*, DNSmsg*, Request*);
+extern void	dnudpserver(char*);
+extern void	dntcpserver(char*);
 
 /* dnnotify.c */
-void	dnnotify(DNSmsg*, DNSmsg*, Request*);
-void	notifyproc(void);
+extern void	dnnotify(DNSmsg*, DNSmsg*, Request*);
+extern void	notifyproc(void);
 
 /* convDNS2M.c */
-int	convDNS2M(DNSmsg*, uchar*, int);
+extern int	convDNS2M(DNSmsg*, uchar*, int);
 
 /* convM2DNS.c */
-char*	convM2DNS(uchar*, int, DNSmsg*, int*);
+extern char*	convM2DNS(uchar*, int, DNSmsg*);
+
+/* malloc.c */
+extern void	mallocsanity(void*);
+extern void	lasthist(void*, int, ulong);
+
+extern int debug;
+extern int traceactivity;
+extern char	*trace;
+extern int	testing;	/* test cache whenever removing a DN */
+extern int	cachedb;
+extern int	needrefresh;
+extern char	*dbfile;
+extern char	mntpt[];
+extern char	*logfile;
+extern int	resolver;
+extern int	norecursion;
+extern int	maxage;		/* age of oldest entry in cache (secs) */
+extern char	*zonerefreshprogram;
+extern int	sendnotifies;
+extern ulong	now;		/* time base */
+extern Area	*owned;
+extern Area	*delegated;
+
+#pragma	varargck	type	"R"	RR*
+#pragma	varargck	type	"Q"	RR*
+

sys/src/cmd/ndb/dnsdebug.c

@@ -6,44 +6,40 @@
 #include <ndb.h>
 #include "dns.h"
 
-enum {
+enum
+{
 	Maxrequest=		128,
+	Ncache=			8,
+	Maxpath=		128,
+	Maxreply=		512,
+	Maxrrr=			16,
 };
 
-extern int inside;
-
 static char *servername;
 static RR *serverrr;
 static RR *serveraddrs;
 
-int	cachedb;
-char	*dbfile;
 int	debug;
-uchar	ipaddr[IPaddrlen];	/* my ip address */
-char	*logfile = "dns";
-int	maxage  = 60;
-char	mntpt[Maxpath];
-int	needrefresh;
+int	cachedb;
 ulong	now;
-int	resolver;
 int	testing;
+int traceactivity;
 char	*trace;
-int	traceactivity;
+int	needrefresh;
+int	resolver;
+uchar	ipaddr[IPaddrlen];	/* my ip address */
+int	maxage;
+char	*logfile = "dns";
+char	*dbfile;
+char	mntpt[Maxpath];
 char	*zonerefreshprogram;
 
-void	docmd(int, char**);
-void	doquery(char*, char*);
-void	preloadserveraddrs(void);
-int	prettyrrfmt(Fmt*);
-int	setserver(char*);
-void	squirrelserveraddrs(void);
-
-void
-usage(void)
-{
-	fprint(2, "%s: [-rx] [-f db-file]\n", argv0);
-	exits("usage");
-}
+int prettyrrfmt(Fmt*);
+void preloadserveraddrs(void);
+void squirrelserveraddrs(void);
+int setserver(char*);
+void doquery(char*, char*);
+void docmd(int, char**);
 
 void
 main(int argc, char *argv[])
@@ -54,12 +50,8 @@ main(int argc, char *argv[])
 	char *f[4];
 
 	strcpy(mntpt, "/net");
-	inside = 1;
 
 	ARGBEGIN{
-	case 'f':
-		dbfile = EARGF(usage());
-		break;
 	case 'r':
 		resolver = 1;
 		break;
@@ -67,8 +59,9 @@ main(int argc, char *argv[])
 		dbfile = "/lib/ndb/external";
 		strcpy(mntpt, "/net.alt");
 		break;
-	default:
-		usage();
+	case 'f':
+		dbfile = ARGF();
+		break;
 	}ARGEND
 
 	now = time(0);
@@ -92,10 +85,14 @@ main(int argc, char *argv[])
 	for(print("> "); p = Brdline(&in, '\n'); print("> ")){
 		p[Blinelen(&in)-1] = 0;
 		n = tokenize(p, f, 3);
-		if(n>=1) {
-			dnpurge();		/* flush the cache */
-			docmd(n, f);
-		}
+		if(n<1)
+			continue;
+
+		/* flush the cache */
+		dnpurge();
+
+		docmd(n, f);
+
 	}
 	exits(0);
 }
@@ -141,7 +138,7 @@ prettyrrfmt(Fmt *f)
 	p = buf;
 	e = buf + sizeof(buf);
 	p = seprint(p, e, "%-32.32s %-15.15s %-5.5s", rp->owner->name,
-		longtime(rp->db? rp->ttl: (rp->ttl - now)),
+		longtime(rp->db ? rp->ttl : (rp->ttl-now)),
 		rrname(rp->type, buf, sizeof buf));
 
 	if(rp->negative){
@@ -158,31 +155,28 @@ prettyrrfmt(Fmt *f)
 	case Tmd:
 	case Tmf:
 	case Tns:
-		seprint(p, e, "\t%s", (rp->host? rp->host->name: ""));
+		seprint(p, e, "\t%s", rp->host->name);
 		break;
 	case Tmg:
 	case Tmr:
-		seprint(p, e, "\t%s", (rp->mb? rp->mb->name: ""));
+		seprint(p, e, "\t%s", rp->mb->name);
 		break;
 	case Tminfo:
-		seprint(p, e, "\t%s %s", (rp->mb? rp->mb->name: ""),
-			(rp->rmb? rp->rmb->name: ""));
+		seprint(p, e, "\t%s %s", rp->mb->name, rp->rmb->name);
 		break;
 	case Tmx:
-		seprint(p, e, "\t%lud %s", rp->pref,
-			(rp->host? rp->host->name: ""));
+		seprint(p, e, "\t%lud %s", rp->pref, rp->host->name);
 		break;
 	case Ta:
 	case Taaaa:
-		seprint(p, e, "\t%s", (rp->ip? rp->ip->name: ""));
+		seprint(p, e, "\t%s", rp->ip->name);
 		break;
 	case Tptr:
-		seprint(p, e, "\t%s", (rp->ptr? rp->ptr->name: ""));
+		seprint(p, e, "\t%s", rp->ptr->name);
 		break;
 	case Tsoa:
-		seprint(p, e, "\t%s %s %lud %lud %lud %lud %lud",
-			rp->host->name, rp->rmb->name, rp->soa->serial,
-			rp->soa->refresh, rp->soa->retry,
+		seprint(p, e, "\t%s %s %lud %lud %lud %lud %lud", rp->host->name,
+			rp->rmb->name, rp->soa->serial, rp->soa->refresh, rp->soa->retry,
 			rp->soa->expire, rp->soa->minttl);
 		break;
 	case Tnull:
@@ -202,14 +196,15 @@ prettyrrfmt(Fmt *f)
 		break;
 	case Tsig:
 		seprint(p, e, "\t%d %d %d %lud %lud %lud %d %s",
-			rp->sig->type, rp->sig->alg, rp->sig->labels,
-			rp->sig->ttl, rp->sig->exp, rp->sig->incep,
-			rp->sig->tag, rp->sig->signer->name);
+			rp->sig->type, rp->sig->alg, rp->sig->labels, rp->sig->ttl,
+			rp->sig->exp, rp->sig->incep, rp->sig->tag, rp->sig->signer->name);
 		break;
 	case Tcert:
 		seprint(p, e, "\t%d %d %d",
 			rp->sig->type, rp->sig->tag, rp->sig->alg);
 		break;
+	default:
+		break;
 	}
 out:
 	return fmtstrcpy(f, buf);
@@ -229,7 +224,8 @@ void
 logreply(int id, uchar *addr, DNSmsg *mp)
 {
 	RR *rp;
-	char buf[12], resp[32];
+	char buf[12];
+	char resp[32];
 
 	switch(mp->flags & Rmask){
 	case Rok:
@@ -263,8 +259,7 @@ logreply(int id, uchar *addr, DNSmsg *mp)
 		mp->flags & (Fauth|Rname) == (Fauth|Rname) ?
 		" nx" : "");
 	for(rp = mp->qd; rp != nil; rp = rp->next)
-		print("\tQ:    %s %s\n", rp->owner->name,
-			rrname(rp->type, buf, sizeof buf));
+		print("\tQ:    %s %s\n", rp->owner->name, rrname(rp->type, buf, sizeof buf));
 	logsection("Ans:  ", mp->an);
 	logsection("Auth: ", mp->ns);
 	logsection("Hint: ", mp->ar);
@@ -317,7 +312,7 @@ squirrelserveraddrs(void)
 			continue;
 		}
 		req.isslave = 1;
-		req.aborttime = now + Maxreqtm*2;	/* be patient */
+		req.aborttime = now + 60;	/* don't spend more than 60 seconds */
 		*l = dnresolve(rp->host->name, Cin, Ta, &req, 0, 0, Recurse, 0, 0);
 		while(*l != nil)
 			l = &(*l)->next;
@@ -330,7 +325,7 @@ void
 preloadserveraddrs(void)
 {
 	RR *rp, **l, *first;
-
+	
 	l = &first;
 	for(rp = serveraddrs; rp != nil; rp = rp->next){
 		rrcopy(rp, l);
@@ -353,29 +348,32 @@ setserver(char *server)
 	if(serveraddrs == nil){
 		print("can't resolve %s\n", servername);
 		resolver = 0;
-	} else
+	} else {
 		resolver = 1;
+	}
 	return resolver ? 0 : -1;
 }
 
 void
 doquery(char *name, char *tstr)
 {
-	int len, type, rooted;
+	Request req;
+	RR *rr, *rp;
+	int len, type;
 	char *p, *np;
+	int rooted;
 	char buf[1024];
-	RR *rr, *rp;
-	Request req;
 
 	if(resolver)
 		preloadserveraddrs();
 
 	/* default to an "ip" request if alpha, "ptr" if numeric */
-	if(tstr == nil || *tstr == 0)
+	if(tstr == nil || *tstr == 0) {
 		if(strcmp(ipattr(name), "ip") == 0)
 			tstr = "ptr";
 		else
 			tstr = "ip";
+	}
 
 	/* if name end in '.', remove it */
 	len = strlen(name);
@@ -416,10 +414,9 @@ doquery(char *name, char *tstr)
 		return;
 	}
 
-	memset(&req, 0, sizeof req);
 	getactivity(&req, 0);
 	req.isslave = 1;
-	req.aborttime = now + Maxreqtm*2;	/* be patient */
+	req.aborttime = now + 60;	/* don't spend more than 60 seconds */
 	rr = dnresolve(buf, Cin, type, &req, 0, 0, Recurse, rooted, 0);
 	if(rr){
 		print("----------------------------\n");
@@ -438,7 +435,8 @@ docmd(int n, char **f)
 	int tmpsrv;
 	char *name, *type;
 
-	name = type = nil;
+	name = nil;
+	type = nil;
 	tmpsrv = 0;
 
 	if(*f[0] == '@') {

sys/src/cmd/ndb/dnserver.c

@@ -15,18 +15,18 @@ int	norecursion;		/* don't allow recursive requests */
  *  answer a dns request
  */
 void
-dnserver(DNSmsg *reqp, DNSmsg *repp, Request *req, uchar *srcip, int rcode)
+dnserver(DNSmsg *reqp, DNSmsg *repp, Request *req)
 {
-	int recursionflag;
-	char *cp, *errmsg;
-	char tname[32];
+	RR *tp, *neg;
+	char *cp;
 	DN *nsdp, *dp;
 	Area *myarea;
-	RR *tp, *neg;
+	char tname[32];
+	int recursionflag;
 
 	dncheck(nil, 1);
 
-	recursionflag = norecursion? 0: Fcanrec;
+	recursionflag = norecursion?0:Fcanrec;
 	memset(repp, 0, sizeof(*repp));
 	repp->id = reqp->id;
 	repp->flags = Fresp | recursionflag | Oquery;
@@ -37,26 +37,14 @@ dnserver(DNSmsg *reqp, DNSmsg *repp, Request *req, uchar *srcip, int rcode)
 	tp->next = 0;
 	repp->qd = tp;
 
-	if (rcode) {
-		errmsg = "";
-		if (rcode >= 0 && rcode < nrname)
-			errmsg = rname[rcode];
-		syslog(0, logfile, "server: response code 0%o (%s), req from %I",
-			rcode, errmsg, srcip);
-		/* provide feedback to clients who send us trash */
-		repp->flags = (rcode&Rmask) | Fresp | Fcanrec | Oquery;
-		return;
-	}
 	if(!rrsupported(repp->qd->type)){
-		syslog(0, logfile, "server: unsupported request %s from %I",
-			rrname(repp->qd->type, tname, sizeof tname), srcip);
+		syslog(0, logfile, "server: request %s", rrname(repp->qd->type, tname, sizeof tname));
 		repp->flags = Runimplimented | Fresp | Fcanrec | Oquery;
 		return;
 	}
 
 	if(repp->qd->owner->class != Cin){
-		syslog(0, logfile, "server: unsupported class %d from %I",
-			repp->qd->owner->class, srcip);
+		syslog(0, logfile, "server: class %d", repp->qd->owner->class);
 		repp->flags = Runimplimented | Fresp | Fcanrec | Oquery;
 		return;
 	}
@@ -64,20 +52,17 @@ dnserver(DNSmsg *reqp, DNSmsg *repp, Request *req, uchar *srcip, int rcode)
 	myarea = inmyarea(repp->qd->owner->name);
 	if(myarea != nil) {
 		if(repp->qd->type == Tixfr || repp->qd->type == Taxfr){
-			syslog(0, logfile,
-				"server: unsupported xfr request %s from %I",
-				rrname(repp->qd->type, tname, sizeof tname),
-				srcip);
-			repp->flags = Runimplimented | Fresp | recursionflag |
-				Oquery;
+			syslog(0, logfile, "server: request %s", rrname(repp->qd->type, tname, sizeof tname));
+			repp->flags = Runimplimented | Fresp | recursionflag | Oquery;
 			return;
 		}
-	} else
+	} else {
 		if(norecursion) {
 			/* we don't recurse and we're not authoritative */
 			repp->flags = Rok | Fresp | Oquery;
 			return;
 		}
+	}
 
 	/*
 	 *  get the answer if we can
@@ -94,12 +79,12 @@ dnserver(DNSmsg *reqp, DNSmsg *repp, Request *req, uchar *srcip, int rcode)
 	/* pass on error codes */
 	if(repp->an == 0){
 		dp = dnlookup(repp->qd->owner->name, repp->qd->owner->class, 0);
-		if(dp->rr == nil)
+		if(dp->rr == 0)
 			if(reqp->flags & Frecurse)
-				repp->flags |= dp->respcode | Fauth;
+				repp->flags |= dp->nonexistent|Fauth;
 	}
 
-	if(myarea == nil)
+	if(myarea == nil){
 		/*
 		 *  add name server if we know
 		 */
@@ -107,7 +92,7 @@ dnserver(DNSmsg *reqp, DNSmsg *repp, Request *req, uchar *srcip, int rcode)
 			nsdp = dnlookup(cp, repp->qd->owner->class, 0);
 			if(nsdp == 0)
 				continue;
-
+	
 			repp->ns = rrlookup(nsdp, Tns, OKneg);
 			if(repp->ns){
 				/* don't pass on anything we know is wrong */
@@ -117,11 +102,12 @@ dnserver(DNSmsg *reqp, DNSmsg *repp, Request *req, uchar *srcip, int rcode)
 				}
 				break;
 			}
-
+	
 			repp->ns = dblookup(cp, repp->qd->owner->class, Tns, 0, 0);
 			if(repp->ns)
 				break;
 		}
+	}
 
 	/*
 	 *  add ip addresses as hints
@@ -134,19 +120,18 @@ dnserver(DNSmsg *reqp, DNSmsg *repp, Request *req, uchar *srcip, int rcode)
 	}
 
 	/*
-	 *  add an soa to the authority section to help client
-	 *  with negative caching
+	 *  add an soa to the authority section to help client with negative caching
 	 */
-	if(repp->an == nil)
+	if(repp->an == nil){
 		if(myarea != nil){
 			rrcopy(myarea->soarr, &tp);
 			rrcat(&repp->ns, tp);
 		} else if(neg != nil) {
 			if(neg->negsoaowner != nil)
-				rrcat(&repp->ns, rrlookup(neg->negsoaowner,
-					Tsoa, NOneg));
+				rrcat(&repp->ns, rrlookup(neg->negsoaowner, Tsoa, NOneg));
 			repp->flags |= neg->negrcode;
 		}
+	}
 
 	/*
 	 *  get rid of duplicates

sys/src/cmd/ndb/dnsquery.c

@@ -106,7 +106,7 @@ main(int argc, char *argv[])
 		}
 
 		seek(fd, 0, 0);
-		if(write(fd, line, n) != n) {
+		if(write(fd, line, n) < 0) {
 			print("!%r\n");
 			continue;
 		}

sys/src/cmd/ndb/dnstcp.c

@@ -1,27 +1,27 @@
-/*
- * dnstcp - serve dns via tcp
- */
 #include <u.h>
 #include <libc.h>
 #include <ip.h>
 #include "dns.h"
 
-extern int inside;
+enum
+{
+	Maxpath=		128,
+};
 
-char	*LOG;
-int	cachedb = 1;
-char	*caller = "";
+char	*logfile = "dns";
 char	*dbfile;
 int	debug;
-uchar	ipaddr[IPaddrlen];	/* my ip address */
-char	*logfile = "dns";
-int	maxage = 60;
-char	mntpt[Maxpath];
+int	cachedb = 1;
+int	testing;
+int traceactivity;
 int	needrefresh;
-ulong	now;
 int 	resolver;
-int	testing;
-int	traceactivity;
+char	mntpt[Maxpath];
+char	*caller = "";
+ulong	now;
+int	maxage;
+uchar	ipaddr[IPaddrlen];	/* my ip address */
+char	*LOG;
 char	*zonerefreshprogram;
 
 static int	readmsg(int, uchar*, int);
@@ -40,14 +40,18 @@ usage(void)
 void
 main(int argc, char *argv[])
 {
-	int len, rcode;
-	uchar buf[512];
-	char tname[32];
-	char *err, *ext = "";
+	int len;
 	Request req;
 	DNSmsg reqmsg, repmsg;
+	uchar buf[512];
+	char tname[32];
+	char *err;
+	char *ext = "";
 
 	ARGBEGIN{
+	case 'R':
+		norecursion = 1;
+		break;
 	case 'd':
 		debug++;
 		break;
@@ -57,9 +61,6 @@ main(int argc, char *argv[])
 	case 'r':
 		resolver = 1;
 		break;
-	case 'R':
-		norecursion = 1;
-		break;
 	case 'x':
 		ext = EARGF(usage());
 		break;
@@ -74,68 +75,61 @@ main(int argc, char *argv[])
 	if(argc > 0)
 		getcaller(argv[0]);
 
-	inside = 1;
 	dninit();
 
-	snprint(mntpt, sizeof mntpt, "/net%s", ext);
+	snprint(mntpt, sizeof(mntpt), "/net%s", ext);
 	if(myipaddr(ipaddr, mntpt) < 0)
 		sysfatal("can't read my ip address");
 	syslog(0, logfile, "dnstcp call from %s to %I", caller, ipaddr);
 
 	db2cache(1);
 
-	memset(&req, 0, sizeof req);
 	setjmp(req.mret);
 	req.isslave = 0;
-	procsetname("main loop");
 
 	/* loop on requests */
 	for(;; putactivity(0)){
 		now = time(0);
-		memset(&repmsg, 0, sizeof repmsg);
+		memset(&repmsg, 0, sizeof(repmsg));
 		alarm(10*60*1000);
-		len = readmsg(0, buf, sizeof buf);
+		len = readmsg(0, buf, sizeof(buf));
 		alarm(0);
 		if(len <= 0)
 			break;
 		getactivity(&req, 0);
 		req.aborttime = now + 15*Min;
-		rcode = 0;
-		memset(&reqmsg, 0, sizeof reqmsg);
-		err = convM2DNS(buf, len, &reqmsg, &rcode);
+		err = convM2DNS(buf, len, &reqmsg);
 		if(err){
-			/* first bytes in buf are source IP addr */
-			syslog(0, logfile, "server: input error: %s from %I",
-				err, buf);
+			syslog(0, logfile, "server: input error: %s from %I", err, buf);
 			break;
 		}
-		if (rcode == 0)
-			if(reqmsg.qdcount < 1){
-				syslog(0, logfile,
-					"server: no questions from %I", buf);
-				break;
-			} else if(reqmsg.flags & Fresp){
-				syslog(0, logfile,
-				    "server: reply not request from %I", buf);
-				break;
-			} else if((reqmsg.flags & Omask) != Oquery){
-				syslog(0, logfile, "server: op %d from %I",
-					reqmsg.flags & Omask, buf);
-				break;
-			}
+		if(reqmsg.qdcount < 1){
+			syslog(0, logfile, "server: no questions from %I", buf);
+			break;
+		}
+		if(reqmsg.flags & Fresp){
+			syslog(0, logfile, "server: reply not request from %I", buf);
+			break;
+		}
+		if((reqmsg.flags & Omask) != Oquery){
+			syslog(0, logfile, "server: op %d from %I", reqmsg.flags & Omask, buf);
+			break;
+		}
+
 		if(debug)
 			syslog(0, logfile, "[%d] %d: serve (%s) %d %s %s",
-				getpid(), req.id, caller,
-				reqmsg.id, reqmsg.qd->owner->name,
+				getpid(),
+				req.id, caller,
+				reqmsg.id,
+				reqmsg.qd->owner->name,
 				rrname(reqmsg.qd->type, tname, sizeof tname));
 
 		/* loop through each question */
-		while(reqmsg.qd) {
-			memset(&repmsg, 0, sizeof repmsg);
-			if(reqmsg.qd->type == Taxfr)
+		while(reqmsg.qd){
+			if(reqmsg.qd->type == Taxfr){
 				dnzone(&reqmsg, &repmsg, &req);
-			else {
-				dnserver(&reqmsg, &repmsg, &req, buf, rcode);
+			} else {
+				dnserver(&reqmsg, &repmsg, &req);
 				reply(1, &repmsg, &req);
 				rrfreelist(repmsg.qd);
 				rrfreelist(repmsg.an);
@@ -143,6 +137,7 @@ main(int argc, char *argv[])
 				rrfreelist(repmsg.ar);
 			}
 		}
+
 		rrfreelist(reqmsg.qd);
 		rrfreelist(reqmsg.an);
 		rrfreelist(reqmsg.ns);
@@ -197,13 +192,12 @@ reply(int fd, DNSmsg *rep, Request *req)
 
 	len = convDNS2M(rep, buf+2, sizeof(buf) - 2);
 	if(len <= 0)
-		abort();	/* "dnserver: converting reply" */
+		abort(); /* "dnserver: converting reply" */;
 	buf[0] = len>>8;
 	buf[1] = len;
 	rv = write(fd, buf, len+2);
 	if(rv != len+2){
-		syslog(0, logfile, "[%d] sending reply: %d instead of %d",
-			getpid(), rv, len+2);
+		syslog(0, logfile, "[%d] sending reply: %d instead of %d", getpid(), rv, len+2);
 		exits(0);
 	}
 }
@@ -268,7 +262,6 @@ dnzone(DNSmsg *reqp, DNSmsg *repp, Request *req)
 	if(repp->an == 0)
 		goto out;
 	rrfreelist(repp->an);
-	repp->an = nil;
 
 	nlen = strlen(dp->name);
 
@@ -302,10 +295,8 @@ dnzone(DNSmsg *reqp, DNSmsg *repp, Request *req)
 	repp->an = rrlookup(dp, Tsoa, NOneg);
 	reply(1, repp, req);
 	rrfreelist(repp->an);
-	repp->an = nil;
 out:
 	rrfree(repp->qd);
-	repp->qd = nil;
 }
 
 static void

sys/src/cmd/ndb/dnudpserver.c

@@ -40,10 +40,10 @@ clientrxmit(DNSmsg *req, uchar *buf)
 	OUdphdr *uh;
 
 	uh = (OUdphdr *)buf;
-	empty = nil;
+	empty = 0;
 	for(p = inprog; p < &inprog[Maxactive]; p++){
 		if(p->inuse == 0){
-			if(empty == nil)
+			if(empty == 0)
 				empty = p;
 			continue;
 		}
@@ -51,10 +51,10 @@ clientrxmit(DNSmsg *req, uchar *buf)
 		if(req->qd->owner == p->owner)
 		if(req->qd->type == p->type)
 		if(memcmp(uh, &p->uh, OUdphdrsize) == 0)
-			return nil;
+			return 0;
 	}
-	if(empty == nil)
-		return nil; /* shouldn't happen: see slave() & Maxactive def'n */
+	if(empty == 0)
+		return 0;	/* shouldn't happen - see slave() and definition of Maxactive */
 
 	empty->id = req->id;
 	empty->owner = req->qd->owner;
@@ -70,13 +70,13 @@ clientrxmit(DNSmsg *req, uchar *buf)
 void
 dnudpserver(char *mntpt)
 {
-	int fd, len, op, rcode;
-	uchar buf[OUdphdrsize + Maxudp + 1024];
-	char *err;
-	char tname[32];
+	int fd, len, op;
 	Request req;
 	DNSmsg reqmsg, repmsg;
+	uchar buf[OUdphdrsize + Maxudp + 1024];
+	char *err;
 	Inprogress *p;
+	char tname[32];
 	OUdphdr *uh;
 
 	/* fork sharing text, data, and bss with parent */
@@ -92,70 +92,56 @@ dnudpserver(char *mntpt)
 	fd = -1;
 	notify(ding);
 restart:
-	procsetname("udp server announcing");
 	if(fd >= 0)
 		close(fd);
 	while((fd = udpannounce(mntpt)) < 0)
 		sleep(5000);
-
-	procsetname("udp server loop");
-	memset(&req, 0, sizeof req);
 	if(setjmp(req.mret))
 		putactivity(0);
 	req.isslave = 0;
-	req.id = 0;
-	req.aborttime = 0;
 
 	/* loop on requests */
 	for(;; putactivity(0)){
-		memset(&repmsg, 0, sizeof repmsg);
-		memset(&reqmsg, 0, sizeof reqmsg);
+		memset(&repmsg, 0, sizeof(repmsg));
+		memset(&reqmsg, 0, sizeof(reqmsg));
 		alarm(60*1000);
-		len = read(fd, buf, sizeof buf);
+		len = read(fd, buf, sizeof(buf));
 		alarm(0);
 		if(len <= OUdphdrsize)
 			goto restart;
 		uh = (OUdphdr*)buf;
 		len -= OUdphdrsize;
-		// syslog(0, logfile, "read received UDP from %I to %I",
-		//	((OUdphdr*)buf)->raddr, ((OUdphdr*)buf)->laddr);
 		getactivity(&req, 0);
-		req.aborttime = now + Maxreqtm;
-		rcode = 0;
-		err = convM2DNS(&buf[OUdphdrsize], len, &reqmsg, &rcode);
+		req.aborttime = now + 30;	/* don't spend more than 30 seconds */
+		err = convM2DNS(&buf[OUdphdrsize], len, &reqmsg);
 		if(err){
-			/* first bytes in buf are source IP addr */
-			syslog(0, logfile, "server: input error: %s from %I",
-				err, buf);
+			syslog(0, logfile, "server: input error: %s from %I", err, buf);
 			continue;
 		}
-		if (rcode == 0)
-			if(reqmsg.qdcount < 1){
-				syslog(0, logfile,
-					"server: no questions from %I", buf);
-				goto freereq;
-			} else if(reqmsg.flags & Fresp){
-				syslog(0, logfile,
-				    "server: reply not request from %I", buf);
-				goto freereq;
-			}
+		if(reqmsg.qdcount < 1){
+			syslog(0, logfile, "server: no questions from %I", buf);
+			goto freereq;
+		}
+		if(reqmsg.flags & Fresp){
+			syslog(0, logfile, "server: reply not request from %I", buf);
+			goto freereq;
+		}
 		op = reqmsg.flags & Omask;
 		if(op != Oquery && op != Onotify){
-			syslog(0, logfile, "server: op %d from %I",
-				reqmsg.flags & Omask, buf);
+			syslog(0, logfile, "server: op %d from %I", reqmsg.flags & Omask, buf);
 			goto freereq;
 		}
 
 		if(debug || (trace && subsume(trace, reqmsg.qd->owner->name))){
 			syslog(0, logfile, "%d: serve (%I/%d) %d %s %s",
-				req.id, buf, uh->rport[0]<<8 | uh->rport[1],
+				req.id, buf, ((uh->rport[0])<<8)+uh->rport[1],
 				reqmsg.id,
 				reqmsg.qd->owner->name,
 				rrname(reqmsg.qd->type, tname, sizeof tname));
 		}
 
 		p = clientrxmit(&reqmsg, buf);
-		if(p == nil){
+		if(p == 0){
 			if(debug)
 				syslog(0, logfile, "%d: duplicate", req.id);
 			goto freereq;
@@ -163,10 +149,10 @@ restart:
 
 		/* loop through each question */
 		while(reqmsg.qd){
-			memset(&repmsg, 0, sizeof repmsg);
+			memset(&repmsg, 0, sizeof(repmsg));
 			switch(op){
 			case Oquery:
-				dnserver(&reqmsg, &repmsg, &req, buf, rcode);
+				dnserver(&reqmsg, &repmsg, &req);
 				break;
 			case Onotify:
 				dnnotify(&reqmsg, &repmsg, &req);
@@ -180,6 +166,7 @@ restart:
 		}
 
 		p->inuse = 0;
+
 freereq:
 		rrfreelist(reqmsg.qd);
 		rrfreelist(reqmsg.an);
@@ -190,6 +177,7 @@ freereq:
 			putactivity(0);
 			_exits(0);
 		}
+
 	}
 }
 
@@ -202,9 +190,10 @@ static char *ohmsg = "oldheaders";
 static int
 udpannounce(char *mntpt)
 {
-	int data, ctl;
-	char dir[64], datafile[64+6];
 	static int whined;
+	int data, ctl;
+	char dir[64];
+	char datafile[64+6];
 
 	/* get a udp port */
 	sprint(datafile, "%s/udp!*!dns", mntpt);
@@ -218,7 +207,7 @@ udpannounce(char *mntpt)
 
 	/* turn on header style interface */
 	if(write(ctl, hmsg, strlen(hmsg)) , 0)
-		abort();			/* hmsg */
+		abort(); /* hmsg */;
 	write(ctl, ohmsg, strlen(ohmsg));
 	data = open(datafile, ORDWR);
 	if(data < 0){
@@ -241,15 +230,14 @@ reply(int fd, uchar *buf, DNSmsg *rep, Request *reqp)
 
 	if(debug || (trace && subsume(trace, rep->qd->owner->name)))
 		syslog(0, logfile, "%d: reply (%I/%d) %d %s %s an %R ns %R ar %R",
-			reqp->id, buf, buf[4]<<8 | buf[5],
+			reqp->id, buf, ((buf[4])<<8)+buf[5],
 			rep->id, rep->qd->owner->name,
-			rrname(rep->qd->type, tname, sizeof tname),
-			rep->an, rep->ns, rep->ar);
+			rrname(rep->qd->type, tname, sizeof tname), rep->an, rep->ns, rep->ar);
 
 	len = convDNS2M(rep, &buf[OUdphdrsize], Maxudp);
 	if(len <= 0){
-		syslog(0, logfile, "error converting reply: %s %d",
-			rep->qd->owner->name, rep->qd->type);
+		syslog(0, logfile, "error converting reply: %s %d", rep->qd->owner->name,
+			rep->qd->type);
 		for(rp = rep->an; rp; rp = rp->next)
 			syslog(0, logfile, "an %R", rp);
 		for(rp = rep->ns; rp; rp = rp->next)

sys/src/cmd/ndb/mkfile

@@ -57,8 +57,6 @@ push: $O.dns $O.dnsdebug $O.dnstcp
 	unmount /n/divisadero
 
 cs.safeinstall: $O.cs
-	if(test -e $BIN/ooocs)
-		mv $BIN/ooocs $BIN/oooocs
 	if(test -e $BIN/oocs)
 		mv $BIN/oocs $BIN/ooocs
 	if(test -e $BIN/ocs)
@@ -67,8 +65,6 @@ cs.safeinstall: $O.cs
 	cp $O.cs $BIN/cs
 
 dns.safeinstall: $O.dns
-	if(test -e $BIN/ooodns)
-		mv $BIN/ooodns $BIN/oooodns
 	if(test -e $BIN/oodns)
 		mv $BIN/oodns $BIN/ooodns
 	if(test -e $BIN/odns)

sys/src/cmd/ndb/query.c

@@ -1,11 +1,11 @@
-/*
- *  search the network database for matches
- */
 #include <u.h>
 #include <libc.h>
 #include <bio.h>
 #include <ndb.h>
 
+/*
+ *  search the database for matches
+ */
 void
 usage(void)
 {
@@ -16,9 +16,10 @@ usage(void)
 void
 search(Ndb *db, char *attr, char *val, char *rattr)
 {
-	char *p;
 	Ndbs s;
-	Ndbtuple *t, *nt;
+	Ndbtuple *t;
+	Ndbtuple *nt;
+	char *p;
 
 	if(rattr){
 		p = ndbgetvalue(db, &s, attr, val, rattr, nil);
@@ -42,16 +43,15 @@ search(Ndb *db, char *attr, char *val, char *rattr)
 void
 main(int argc, char **argv)
 {
-	int reps = 1;
-	char *rattr = nil, *dbfile = nil;
+	char *rattr = 0;
 	Ndb *db;
+	char *dbfile = 0;
+	int reps = 1;
 
 	ARGBEGIN{
 	case 'f':
 		dbfile = ARGF();
 		break;
-	default:
-		usage();
 	}ARGEND;
 
 	switch(argc){

sys/src/cmd/ndb/time.c

@@ -0,0 +1,26 @@
+#include <u.h>
+#include <libc.h>
+
+static Lock tlock;
+
+long
+time(long *tp)
+{
+	char b[20];
+	static int f = -1;
+	long t;
+
+	lock(&tlock);
+	memset(b, 0, sizeof(b));
+	f = open("/dev/time", OREAD|OCEXEC);
+	if(f >= 0) {
+		seek(f, 0, 0);
+		read(f, b, sizeof(b));
+	}
+	t = atol(b);
+	if(tp)
+		*tp = t;
+	unlock(&tlock);
+
+	return t;
+}

sys/src/fs/dev/juke.c

@@ -326,6 +326,7 @@ devtojuke(Device *d, Device *top)
 			/* FALL THROUGH */
 		case Devwren:
 		case Devide:
+		case Devmarvsata:
 			return nil;
 
 		case Devcw:

sys/src/fs/pc/lock.c

@@ -9,16 +9,22 @@ void
 lock(Lock *l)
 {
 	int i;
+	ulong caller;
 
+	caller = getcallerpc(&l);
 	/*
 	 * Try the fast grab first
 	 */
 loop:
-    	if(tas(l) == 0)
+    	if(tas(l) == 0) {
+		l->pc = caller;
 		return;
+	}
 	for(i = 0; i < 1000000; i++) {
-    		if(tas(l) == 0)
+    		if(tas(l) == 0) {
+			l->pc = caller;
 			return;
+		}
 		/* If we are spl low resched */
 		if(getstatus() & IFLAG)
 			sched();
@@ -26,7 +32,7 @@ loop:
 	l->sbsem = 0;
 
 	print("lock loop 0x%lux called by 0x%lux held by pc 0x%lux\n", (ulong)l,
-		getcallerpc(&l), l->pc);
+		caller, l->pc);
 	goto loop;
 }
 

sys/src/fs/port/con.c

@@ -428,24 +428,25 @@ cmd_date(int argc, char *argv[])
 
 	ct = time();
 	arg = argv[1];
+	t = number(arg+1, 0, 10);
 	switch(*arg) {
 	default:
 		t = number(arg, -1, 10);
 		if(t <= 0)
 			goto out;
+		/* fall through */
+	case '=':
 		ct = t;
 		break;
 	case '+':
-		t = number(arg+1, 0, 10);
 		ct += t;
 		break;
 	case '-':
-		t = number(arg+1, 0, 10);
 		ct -= t;
+		break;
 	}
 	settime(ct);
 	setrtc(ct);
-
 out:
 	prdate();
 }
@@ -455,13 +456,11 @@ cmd_fstat(int argc, char *argv[])
 {
 	int i;
 
-	for(i=1; i<argc; i++) {
-		if(walkto(argv[i])) {
+	for(i=1; i<argc; i++)
+		if(walkto(argv[i]))
 			print("cant stat %s\n", argv[i]);
-			continue;
-		}
-		con_fstat(FID2);
-	}
+		else
+			con_fstat(FID2);
 }
 
 void
@@ -820,7 +819,7 @@ installcmds(void)
 	cmd_install("check", "[options]", cmd_check);
 	cmd_install("clri", "[file ...] -- purge files/dirs", cmd_clri);
 	cmd_install("create", "path uid gid perm [lad] -- make a file/dir", cmd_create);
-	cmd_install("date", "[[+-]seconds] -- print/set date", cmd_date);
+	cmd_install("date", "[[=+-]seconds] -- print/set date", cmd_date);
 	cmd_install("disallow", "-- enable permission checking", cmd_disallow);
 	cmd_install("duallow", "uid -- duallow", cmd_duallow);
 	cmd_install("flag", "-- print set flags", cmd_flag);
@@ -888,11 +887,10 @@ number(char *arg, int def, int base)
 	int c, sign, any;
 	vlong n;
 
-	if(arg == 0)
+	if(arg == nil)
 		return def;
 
-	sign = 0;
-	any = 0;
+	sign = any = 0;
 	n = 0;
 
 	c = *arg;
@@ -911,8 +909,7 @@ number(char *arg, int def, int base)
 		n *= base;
 		if(c >= 'a' && c <= 'f')
 			n += c - 'a' + 10;
-		else
-		if(c >= 'A' && c <= 'F')
+		else if(c >= 'A' && c <= 'F')
 			n += c - 'A' + 10;
 		else
 			n += c - '0';

sys/src/fs/port/time.c

@@ -183,11 +183,12 @@ static	struct
 	short	dayle;
 } daytab[] =
 {
-	87,	999,	90,	303,
+	107,	~(ushort)0>>1, 66, 310,
+	87,	106,	90,	303,
 	76,	86,	119,	303,
 	75,	75,	58,	303,
 	74,	74,	5,	333,
-	0,	73,	119,	303,
+	-1,	73,	119,	303,
 };
 
 static
@@ -221,7 +222,14 @@ localtime(Timet tim, Tm *ct)
 	copyt = tim - conf.minuteswest*60L;
 	gmtime(copyt, ct);
 	dayno = ct->yday;
-	for(i=0;; i++)
+
+	/* enforce sane bounds for daytab */
+	if (ct->year < -1) /* 1 jan 1970 00:00 GMT can be 31 dec 1969 locally */
+		ct->year = -1;
+	else if (ct->year > 60000)
+		ct->year = 60000;
+
+	for(i = 0; ; i++)
 		if(ct->year >= daytab[i].yrfrom &&
 		   ct->year <= daytab[i].yrto) {
 			daylbegin = succsunday(ct, daytab[i].daylb);
@@ -229,8 +237,8 @@ localtime(Timet tim, Tm *ct)
 			break;
 		}
 	if(conf.dsttime &&
-	    (dayno>daylbegin || (dayno==daylbegin && ct->hour>=2)) &&
-	    (dayno<daylend || (dayno==daylend && ct->hour<1))) {
+	    (dayno>daylbegin || (dayno==daylbegin && ct->hour >= 2)) &&
+	    (dayno<daylend   || (dayno==daylend   && ct->hour < 1))) {
 		copyt += 60L*60L;
 		gmtime(copyt, ct);
 		ct->isdst++;

sys/src/libc/9syscall/mkfile

@@ -8,12 +8,7 @@ install:V:
 		n=`{sed -n '/[ 	]'$I'[ 	]/s/.*	//p' sys.h}
 		if(~ $i exits) i=_exits
 		{switch($objtype){
-		case 68000
-			echo TEXT $i'(SB)', 1, '$0'
-			echo MOVL '$'$n, R0
-			echo TRAP '$0'
-			echo RTS
-		case 68020
+		case 68000 68020
 			echo TEXT $i'(SB)', 1, '$0'
 			echo MOVL '$'$n, R0
 			echo TRAP '$0'

sys/src/libndb/ndbopen.c

@@ -160,7 +160,7 @@ ndbchanged(Ndb *db)
 	Dir *d;
 
 	for(ndb = db; ndb != nil; ndb = ndb->next){
-		d = dirfstat(Bfildes(&db->b));
+		d = dirfstat(Bfildes(&ndb->b));
 		if(d == nil)
 			continue;
 		if(ndb->qid.path != d->qid.path