← Back to branch summary

~ubuntu-branches/ubuntu/saucy/maradns/saucy

« back to all changes in this revision

Viewing changes to update/1.2.06/maradns-1.2.05-log_write.patch

  • Committer: Bazaar Package Importer
  • Author(s): Kai Hendry
  • Date: 2006-10-09 17:44:21 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20061009174421-yb151elg3m4t5shl
Tags: 1.2.12.03-1
* New upstream release with many new doc tweaks. Though most of the changes
  are with the webpages which I have chosen not to distribute as you can
  read them all rather online at http://maradns.org/
* The diffs in the Makefiles are due to upstream's configure script
* Added bind2csv2.py as an example from upstream's tools/
  There is a lot of little scripts in tools/ which can probably join this

Show diffs side-by-side

added added

removed removed

Lines of Context:
update/1.2.06/maradns-1.2.05-log_write.patch
1
 
--- maradns-1.2.06-orig/server/MaraDNS.c        2006-03-10 00:33:28.000000000 -0800
2
 
+++ maradns-1.2.06/server/MaraDNS.c     2006-03-10 00:45:13.000000000 -0800
3
 
@@ -155,6 +155,12 @@
4
 
        return synth_soa_serial;
5
 
 }
6
 
 
7
 
+/* Define log_lock(); and log_unlock(); for authonly use */
8
 
+#ifdef AUTHONLY
9
 
+#define log_lock()
10
 
+#define log_unlock()
11
 
+#endif /* AUTHONLY */
12
 
+
13
 
 /* Debug routine that shows an IP in dotted decimal format on the
14
 
    standard output.
15
 
    Input:  A uint32 ip
16
 
@@ -186,8 +192,11 @@
17
 
 
18
 
 /* Signal handler for SIGPIPE, so we don't terminate */
19
 
 void handle_sigpipe() {
20
 
-    if(log_level > 1)
21
 
+    if(log_level > 1) {
22
 
+        log_lock();
23
 
         printf("%s%s",L_CAUGHT_PIPE,L_N); /* "Caught SIGPIPE" */
24
 
+        log_unlock();
25
 
+        }
26
 
     return;
27
 
     }
28
 
 
29
 
@@ -201,8 +210,11 @@
30
 
 
31
 
 /* Signal handler for other signals */
32
 
 void handle_signal() {
33
 
-    if(log_level > 1)
34
 
+    if(log_level > 1) {
35
 
+        log_lock();
36
 
         printf("%s%s",L_CAUGHT_SIG,L_N); /* "Caught Signal" */
37
 
+        log_unlock();
38
 
+        }
39
 
     return;
40
 
     }
41
 
 
42
 
@@ -227,12 +239,14 @@
43
 
 
44
 
     if(logmessage == 0)
45
 
         return JS_ERROR;
46
 
+    log_lock();
47
 
     show_timestamp();
48
 
     printf("%s%s%s",L_LOG,logmessage,L_N);
49
 
           /* "Log: ", logmessage, "\n" */
50
 
 
51
 
     /* Unbuffered output */
52
 
     fflush(stdout);
53
 
+    log_unlock();
54
 
 
55
 
     return JS_SUCCESS;
56
 
     }
57
 
@@ -249,12 +263,14 @@
58
 
     if(log_level == 0)
59
 
         return JS_SUCCESS;
60
 
 
61
 
+    log_lock();
62
 
     printf("%s",L_LOG); /* "Log: " */
63
 
     ret = show_esc_stdout(logmessage);
64
 
     printf("%s",L_N); /* "\n" */
65
 
 
66
 
     /* Unbuffered output */
67
 
     fflush(stdout);
68
 
+    log_unlock();
69
 
 
70
 
     return ret;
71
 
     }
72
 
@@ -269,12 +285,14 @@
73
 
         return JS_SUCCESS;
74
 
     if(left == 0)
75
 
         return JS_ERROR;
76
 
+    log_lock();
77
 
     printf("%s%s",L_LOG,left); /* "Log: ", left */
78
 
     ret = show_esc_stdout(right);
79
 
     printf("%s",L_N); /* "\n" */
80
 
 
81
 
     /* Unbuffered output */
82
 
     fflush(stdout);
83
 
+    log_unlock();
84
 
 
85
 
     return ret;
86
 
     }
87
 
@@ -892,11 +910,15 @@
88
 
     if(compress_data(most,ar) == JS_ERROR) {
89
 
         /* This is a bit of a kludge to work around the news.com.com
90
 
            problem for the 1.0.00 release */
91
 
-        show_timestamp();
92
 
-        printf("%s",L_COMPRESS_ERROR);
93
 
-        /* Compress error */
94
 
-        show_esc_stdout(most);
95
 
-        printf("\n");
96
 
+        if(log_level > 2) {
97
 
+            log_lock();
98
 
+            show_timestamp();
99
 
+            printf("%s",L_COMPRESS_ERROR);
100
 
+            /* Compress error */
101
 
+            show_esc_stdout(most);
102
 
+            printf("\n");
103
 
+            log_unlock();
104
 
+            }
105
 
         if(js_copy(most,ar) == JS_ERROR) {
106
 
             js_destroy(ar);
107
 
            if(client != 0) {
108
 
@@ -1812,7 +1834,7 @@
109
 
                        js_destroy(out);
110
 
                        return 0;
111
 
                }
112
 
-               printf("point %d length %d\n",point,length);
113
 
+               /* printf("point %d length %d\n",point,length); */
114
 
                point += length + 1;
115
 
                if(point > dname_they_wanted->unit_count) {
116
 
                        js_destroy(out);
117
 
@@ -3232,7 +3254,9 @@
118
 
            js_dealloc(query_string);
119
 
            if(result_code == JS_SUCCESS) {
120
 
                log_level = new_verbose_level; 
121
 
+               log_lock();
122
 
                printf("Verbose_level remotely set to %d\n",new_verbose_level); 
123
 
+               log_unlock();
124
 
 #ifndef AUTHONLY
125
 
                init_rlog_level(new_verbose_level); 
126
 
 #endif
127
 
@@ -4675,6 +4699,7 @@
128
 
                }
129
 
 #endif /* __CYGWIN__ */
130
 
 #endif
131
 
+               log_lock();
132
 
                 show_timestamp();
133
 
                 printf("%s ","Query from");
134
 
                if(ect.type == 4) {
135
 
@@ -4692,14 +4717,17 @@
136
 
                 printf("has decompression error: ");
137
 
                 show_esc_stdout(incoming);
138
 
                 printf("\n");
139
 
+                log_unlock();
140
 
                 }
141
 
             continue;
142
 
             }
143
 
         if(log_level >= 5) {
144
 
+            log_lock();
145
 
             show_timestamp();
146
 
             printf("Decompressed packet: ");
147
 
             show_esc_stdout(uncomp);
148
 
             printf("\n");
149
 
+            log_unlock();
150
 
             }
151
 
         if(log_level >= 3 && uncomp->unit_count > 12) {
152
 
             /* Show them the query */
153
 
@@ -4715,6 +4743,7 @@
154
 
 #endif
155
 
                 hname_translate(incoming,value);
156
 
                 /* Yes, I know, put these in the "to localize" header file */
157
 
+                log_lock();
158
 
                 show_timestamp();
159
 
                 printf("%s: ","Query from");
160
 
                if(ect.type == 4) {
161
 
@@ -4732,6 +4761,7 @@
162
 
                 printf(" ");
163
 
                 js_show_stdout(incoming);
164
 
                 printf("\n");
165
 
+                log_unlock();
166
 
                 }
167
 
             }
168
 
         /* Delay the processing the request, as needed */
169
 
--- maradns-1.2.06-orig/server/recursive.c      2006-03-10 00:33:28.000000000 -0800
170
 
+++ maradns-1.2.06/server/recursive.c   2006-03-10 00:51:41.000000000 -0800
171
 
@@ -58,7 +58,7 @@
172
 
 /* The locks used for multithreaded purposes */
173
 
 pthread_mutex_t big_lock = PTHREAD_MUTEX_INITIALIZER;
174
 
 int in_big_lock = 0;
175
 
-pthread_mutex_t log_lock = PTHREAD_MUTEX_INITIALIZER;
176
 
+pthread_mutex_t logwrite_lock = PTHREAD_MUTEX_INITIALIZER;
177
 
 pthread_mutex_t rng_lock = PTHREAD_MUTEX_INITIALIZER;
178
 
 pthread_mutex_t thr_lock = PTHREAD_MUTEX_INITIALIZER;
179
 
 
180
 
@@ -176,12 +176,12 @@
181
 
 /* A list of spam-friendly DNS servers (e.g. azmalink.net, etc.) */
182
 
 ipv4pair spammers[512];
183
 
 
184
 
-void logwrite_lock() {
185
 
-    pthread_mutex_lock(&log_lock);
186
 
+void log_lock() {
187
 
+    pthread_mutex_lock(&logwrite_lock);
188
 
     }
189
 
     
190
 
-void logwrite_unlock() {
191
 
-    pthread_mutex_unlock(&log_lock);
192
 
+void log_unlock() {
193
 
+    pthread_mutex_unlock(&logwrite_lock);
194
 
     }
195
 
     
196
 
 void do_big_lock() {
197
 
@@ -191,10 +191,10 @@
198
 
     
199
 
 void big_unlock() {
200
 
     if(in_big_lock != 1) {
201
 
-        logwrite_lock();
202
 
+        log_lock();
203
 
         show_timestamp();
204
 
        printf("WARNING: Attempting to unlock when not locked\n");
205
 
-        logwrite_unlock();
206
 
+        log_unlock();
207
 
        return;
208
 
        }
209
 
     in_big_lock = 0;
210
 
@@ -469,12 +469,12 @@
211
 
         bye = zap->record;
212
 
 
213
 
         if(rlog_level >= 4) {
214
 
-           logwrite_lock();
215
 
+           log_lock();
216
 
             show_timestamp();
217
 
             printf("Custodian is zapping record ");
218
 
             show_esc_stdout(zap->hash_point);
219
 
             printf(" at %p\n",zap->record);
220
 
-           logwrite_unlock();
221
 
+           log_unlock();
222
 
             }
223
 
 
224
 
         /* Remove the pointer to this hash element */
225
 
@@ -631,10 +631,10 @@
226
 
 
227
 
     if(depth > 32) {
228
 
         if(rlog_level >= 4) {
229
 
-           logwrite_lock();
230
 
+           log_lock();
231
 
            show_timestamp();
232
 
            printf(" unlinking depth exceeded\n");
233
 
-           logwrite_unlock();
234
 
+           log_unlock();
235
 
            }
236
 
         return JS_ERROR; /* Maximum allowed depth is 32 */
237
 
        }
238
 
@@ -642,11 +642,11 @@
239
 
     while(fatma != 0) {
240
 
 
241
 
         if(rlog_level >= 4) {
242
 
-           logwrite_lock();
243
 
+           log_lock();
244
 
             show_timestamp();
245
 
            printf("Unlinking RR at %p, depth %d, next %p\n",fatma,depth,
246
 
                   fatma->next);
247
 
-           logwrite_unlock();
248
 
+           log_unlock();
249
 
            }
250
 
 
251
 
         if(fatma->ip != 0)
252
 
@@ -655,18 +655,18 @@
253
 
         /* We normally do not destroy fatma->query because that js string
254
 
            object has normally already been destroyed */
255
 
         if(rlog_level >= 4) {
256
 
-            logwrite_lock();
257
 
+            log_lock();
258
 
             show_timestamp();
259
 
             printf("Destroying data at %p\n",fatma->data);
260
 
-            logwrite_unlock();
261
 
+            log_unlock();
262
 
             }
263
 
         js_destroy(fatma->data);
264
 
         if(fatma->ptr != 0) {
265
 
             if(rlog_level >= 4) {
266
 
-                logwrite_lock();
267
 
+                log_lock();
268
 
                 show_timestamp();
269
 
                 printf("Destroying ptr at %p\n",fatma->ptr);
270
 
-                logwrite_unlock();
271
 
+                log_unlock();
272
 
                 }
273
 
             js_destroy(fatma->ptr);
274
 
             }
275
 
@@ -674,10 +674,10 @@
276
 
            separate js_string object that also needs to be nuked */
277
 
         if(fatma->zap == NULL && depth >= 1) {
278
 
             if(rlog_level >= 4) {
279
 
-                logwrite_lock();
280
 
+                log_lock();
281
 
                 show_timestamp();
282
 
                 printf("Destroying query at %p\n",fatma->query);
283
 
-                logwrite_unlock();
284
 
+                log_unlock();
285
 
                 }
286
 
             js_destroy(fatma->query);
287
 
             }
288
 
@@ -693,10 +693,10 @@
289
 
             }
290
 
 
291
 
         if(rlog_level >= 4) {
292
 
-           logwrite_lock();
293
 
+           log_lock();
294
 
            show_timestamp();
295
 
            printf("Destroying remember at %p\n",remember);
296
 
-           logwrite_unlock();
297
 
+           log_unlock();
298
 
            }
299
 
 
300
 
         js_dealloc(remember);
301
 
@@ -1082,12 +1082,12 @@
302
 
         return JS_ERROR;
303
 
 
304
 
     if(rlog_level >= 4) {
305
 
-        logwrite_lock();
306
 
+        log_lock();
307
 
         show_timestamp();
308
 
         printf("Adding RR/psudo-NXDOMAIN ");
309
 
         show_esc_stdout(query);
310
 
         printf(" to cache at %p\n",data);
311
 
-        logwrite_unlock();
312
 
+        log_unlock();
313
 
         }
314
 
 
315
 
     /* First, clear out all the fields */
316
 
@@ -1224,11 +1224,11 @@
317
 
            currently there */
318
 
         if(action == OVERWRITE || spot_data.datatype == MARA_DNS_NS) {
319
 
             if(rlog_level >= 4) {
320
 
-               logwrite_lock();
321
 
+               log_lock();
322
 
                 show_timestamp();
323
 
                 printf("Element already in hash at %p, zapping\n",
324
 
                       spot_data.value);
325
 
-               logwrite_unlock();
326
 
+               log_unlock();
327
 
                 }
328
 
 
329
 
             if(add_zap == 0)
330
 
@@ -1258,11 +1258,11 @@
331
 
             }
332
 
         else if(action == 2) { /* Append */
333
 
             if(rlog_level >= 4) {
334
 
-               logwrite_lock();
335
 
+               log_lock();
336
 
                 show_timestamp();
337
 
                 printf("Appending element in hash at %p\n",
338
 
                       spot_data.value);
339
 
-               logwrite_unlock();
340
 
+               log_unlock();
341
 
                 }
342
 
             point = spot_data.value;
343
 
             while(point->next != NULL)
344
 
@@ -1302,12 +1302,12 @@
345
 
         data->zap = new_fila(data,0,zap_query,2);
346
 
 
347
 
     if(rlog_level >= 4) {
348
 
-       logwrite_lock();
349
 
+       log_lock();
350
 
         show_timestamp();
351
 
         printf("Sucessfully added ");
352
 
         show_esc_stdout(query);
353
 
         printf(" to cache at %p\n",data);
354
 
-       logwrite_unlock();
355
 
+       log_unlock();
356
 
         }
357
 
 
358
 
     return JS_SUCCESS;
359
 
@@ -1498,12 +1498,12 @@
360
 
     if(remote_ip == 0xffffffff || remote_ip == 0) { /* 255.255.255.255
361
 
                                                        and 0.0.0.0 */
362
 
         if(rlog_level >= 4) {
363
 
-            logwrite_lock();
364
 
+            log_lock();
365
 
             show_timestamp();
366
 
             printf("Invalid ip ");
367
 
             debug_show_ip(remote_ip);
368
 
             printf(" rejected\n");
369
 
-            logwrite_unlock();
370
 
+            log_unlock();
371
 
             }
372
 
         return JS_ERROR;
373
 
         }
374
 
@@ -1511,7 +1511,7 @@
375
 
     /* End variable declaration, begin code */
376
 
 
377
 
     if(rlog_level >= 4) {
378
 
-        logwrite_lock();
379
 
+        log_lock();
380
 
         show_timestamp();
381
 
         printf("Querying DNS server with ip ");
382
 
         debug_show_ip(remote_ip);
383
 
@@ -1520,7 +1520,7 @@
384
 
         printf(" with bailiwick ");
385
 
         show_esc_stdout(bailiwick);
386
 
         printf("\n");
387
 
-        logwrite_unlock();
388
 
+        log_unlock();
389
 
         }
390
 
 
391
 
     /* Make sure they are not a spammer.  If they are, return an error */
392
 
@@ -1529,11 +1529,11 @@
393
 
         if((remote_ip & (spammers[counter]).mask) ==
394
 
             ((spammers[counter]).ip & (spammers[counter]).mask)) {
395
 
             if(rlog_level >= 4) {
396
 
-                logwrite_lock();
397
 
+                log_lock();
398
 
                 show_timestamp();
399
 
                 debug_show_ip(remote_ip);
400
 
                 printf(" is a DNS server we won't talk to\n");
401
 
-                logwrite_unlock();
402
 
+                log_unlock();
403
 
                 }
404
 
             return JS_ERROR; /* We do not welcome replies from spam-friendly
405
 
                                 DNS servers */
406
 
@@ -1548,29 +1548,29 @@
407
 
     /* Allocate memory for some strings */
408
 
     if((indata = js_create(512,1)) == 0) {
409
 
         if(rlog_level >= 4) {
410
 
-            logwrite_lock();
411
 
+            log_lock();
412
 
             show_timestamp();
413
 
             printf("Unable to allocate indata string\n");
414
 
-            logwrite_unlock();
415
 
+            log_unlock();
416
 
             }
417
 
         return JS_ERROR;
418
 
        }
419
 
     if((uindata = js_create(2048,1)) == 0) {
420
 
         if(rlog_level >= 4) {
421
 
-            logwrite_lock();
422
 
+            log_lock();
423
 
             show_timestamp();
424
 
             printf("Unable to allocate uindata string\n");
425
 
-            logwrite_unlock();
426
 
+            log_unlock();
427
 
             }
428
 
         js_destroy(indata);
429
 
         return JS_ERROR;
430
 
         }
431
 
     if((outdata = js_create(512,1)) == 0) {
432
 
         if(rlog_level >= 4) {
433
 
-            logwrite_lock();
434
 
+            log_lock();
435
 
             show_timestamp();
436
 
             printf("Unable to allocate outdata string\n");
437
 
-            logwrite_unlock();
438
 
+            log_unlock();
439
 
             }
440
 
         js_destroy(indata);
441
 
         js_destroy(uindata);
442
 
@@ -1583,10 +1583,10 @@
443
 
     server.sin_port = htons(53);
444
 
     if((server.sin_addr.s_addr = htonl(remote_ip)) == INADDR_NONE) {
445
 
         if(rlog_level >= 4) {
446
 
-            logwrite_lock();
447
 
+            log_lock();
448
 
             show_timestamp();
449
 
             printf("Failure running htonl\n");
450
 
-            logwrite_unlock();
451
 
+            log_unlock();
452
 
             }
453
 
         goto cleanup;
454
 
        }
455
 
@@ -1624,28 +1624,28 @@
456
 
     /* Make a beginning of a DNS query from that header */
457
 
     if(make_hdr(&header,outdata) == JS_ERROR) {
458
 
         if(rlog_level >= 4) {
459
 
-            logwrite_lock();
460
 
+            log_lock();
461
 
             show_timestamp();
462
 
             printf("Failure running make_hdr\n");
463
 
-            logwrite_unlock();
464
 
+            log_unlock();
465
 
             }
466
 
         goto cleanup;
467
 
        }
468
 
     if(js_append(query,outdata) == JS_ERROR) {
469
 
         if(rlog_level >= 4) {
470
 
-            logwrite_lock();
471
 
+            log_lock();
472
 
             show_timestamp();
473
 
             printf("Failure running js_append\n");
474
 
-            logwrite_unlock();
475
 
+            log_unlock();
476
 
             }
477
 
         goto cleanup;
478
 
        }
479
 
     if(js_adduint16(outdata,1) == JS_ERROR) { /* Adding class to query */
480
 
         if(rlog_level >= 4) {
481
 
-            logwrite_lock();
482
 
+            log_lock();
483
 
             show_timestamp();
484
 
             printf("Failure running js_adduint16\n");
485
 
-            logwrite_unlock();
486
 
+            log_unlock();
487
 
             }
488
 
         goto cleanup;
489
 
        }
490
 
@@ -1659,10 +1659,10 @@
491
 
     /* Create a UDP client socket */
492
 
     if((s = socket(AF_INET,SOCK_DGRAM,0)) == -1) {
493
 
         if(rlog_level >= 2) {
494
 
-            logwrite_lock();
495
 
+            log_lock();
496
 
             show_timestamp();
497
 
             printf("WARNING: Failure creating socket\n");
498
 
-            logwrite_unlock();
499
 
+            log_unlock();
500
 
             }
501
 
         goto cleanup;
502
 
        }
503
 
@@ -1673,10 +1673,10 @@
504
 
     /* Try 10 times just in case the port is already bound */
505
 
     do {
506
 
         if(rlog_level >= 4 && counter > 0) {
507
 
-           logwrite_lock();
508
 
+           log_lock();
509
 
            show_timestamp();
510
 
            printf("Bind failed, trying again\n");
511
 
-           logwrite_unlock();
512
 
+           log_unlock();
513
 
            }
514
 
         /* XXX read some kvars which determine the range of this 
515
 
           (V1.2 feature) */
516
 
@@ -1688,10 +1688,10 @@
517
 
     if(counter >= 10) {
518
 
         close(s);
519
 
         if(rlog_level >= 4) {
520
 
-            logwrite_lock();
521
 
+            log_lock();
522
 
             show_timestamp();
523
 
             printf("Failure binding, giving up\n");
524
 
-            logwrite_unlock();
525
 
+            log_unlock();
526
 
             }
527
 
         goto cleanup;
528
 
        }
529
 
@@ -1705,10 +1705,10 @@
530
 
     if(counter < 0) {
531
 
         close(s);
532
 
         if(rlog_level >= 4) {
533
 
-            logwrite_lock();
534
 
+            log_lock();
535
 
             show_timestamp();
536
 
             printf("Sendto failure\n");
537
 
-            logwrite_unlock();
538
 
+            log_unlock();
539
 
             }
540
 
         goto cleanup;
541
 
         }
542
 
@@ -1724,10 +1724,10 @@
543
 
     do_big_lock();
544
 
     if(n == -1)  /* select error */ {
545
 
         if(rlog_level >= 4) {
546
 
-            logwrite_lock();
547
 
+            log_lock();
548
 
             show_timestamp();
549
 
             printf("Select error\n");
550
 
-            logwrite_unlock();
551
 
+            log_unlock();
552
 
             }
553
 
         close(s);
554
 
         goto cleanup;
555
 
@@ -1735,10 +1735,10 @@
556
 
     if(n == 0) /* Timeout */ {
557
 
         close(s);
558
 
         if(rlog_level >= 4) {
559
 
-            logwrite_lock();
560
 
+            log_lock();
561
 
             show_timestamp();
562
 
             printf("Timeout contacting remote nameserver\n");
563
 
-            logwrite_unlock();
564
 
+            log_unlock();
565
 
             }
566
 
         goto minus2;
567
 
         }
568
 
@@ -1754,10 +1754,10 @@
569
 
                          (socklen_t *)&len_inet)) < 0) {
570
 
         close(s);
571
 
         if(rlog_level >= 4) {
572
 
-            logwrite_lock();
573
 
+            log_lock();
574
 
             show_timestamp();
575
 
             printf("recvfrom error\n");
576
 
-            logwrite_unlock();
577
 
+            log_unlock();
578
 
             }
579
 
         goto minus3;
580
 
         }
581
 
@@ -1767,29 +1767,29 @@
582
 
     indata->unit_count = count;
583
 
     if(decompress_data(indata,uindata) == JS_ERROR) {
584
 
         if(rlog_level >= 4) {
585
 
-            logwrite_lock();
586
 
+            log_lock();
587
 
             show_timestamp();
588
 
             printf("Decompress failure: ");
589
 
            show_esc_stdout(indata);
590
 
            printf("\n");
591
 
-            logwrite_unlock();
592
 
+            log_unlock();
593
 
             }
594
 
         goto minus3;
595
 
         } 
596
 
     if(rlog_level >= 5) {
597
 
-        logwrite_lock();
598
 
+        log_lock();
599
 
        show_timestamp();
600
 
        printf("Decompressed packet: ");
601
 
        show_esc_stdout(uindata);
602
 
        printf("\n");
603
 
-       logwrite_unlock();
604
 
+       log_unlock();
605
 
        }
606
 
     if(read_hdr(uindata,&header) == JS_ERROR) {
607
 
         if(rlog_level >= 4) {
608
 
-            logwrite_lock();
609
 
+            log_lock();
610
 
             show_timestamp();
611
 
             printf("read_hdr failure\n");
612
 
-            logwrite_unlock();
613
 
+            log_unlock();
614
 
             }
615
 
         goto minus3;
616
 
        }
617
 
@@ -1816,10 +1816,10 @@
618
 
 
619
 
     if(header.id != sid) {
620
 
         if(rlog_level >= 4) {
621
 
-            logwrite_lock();
622
 
+            log_lock();
623
 
             show_timestamp();
624
 
             printf("Bad id from remote server (possible spoof attempt)\n");
625
 
-            logwrite_unlock();
626
 
+            log_unlock();
627
 
             }
628
 
         goto cleanup;
629
 
        }
630
 
@@ -1829,10 +1829,10 @@
631
 
        keen on resolving macslash.net */
632
 
     if(header.rcode != 0 && header.rcode != 3) {
633
 
         if(rlog_level >= 4) {
634
 
-           logwrite_lock();
635
 
+           log_lock();
636
 
            show_timestamp();
637
 
            printf("Bad rcode from remote server\n");
638
 
-           logwrite_unlock();
639
 
+           log_unlock();
640
 
            }
641
 
         goto cleanup;
642
 
        }
643
 
@@ -1844,10 +1844,10 @@
644
 
         len = dlabel_length(uindata,offset);
645
 
         if(len == JS_ERROR) {
646
 
             if(rlog_level >= 4) {
647
 
-                logwrite_lock();
648
 
+                log_lock();
649
 
                 show_timestamp();
650
 
                 printf("Bad dlabel_length\n");
651
 
-                logwrite_unlock();
652
 
+                log_unlock();
653
 
                 }
654
 
             goto cleanup;
655
 
            }
656
 
@@ -1874,10 +1874,10 @@
657
 
             len = dlabel_length(uindata,offset);
658
 
             if(len == JS_ERROR) {
659
 
                 if(rlog_level >= 4) {
660
 
-                    logwrite_lock();
661
 
+                    log_lock();
662
 
                     show_timestamp();
663
 
                     printf("Bad dlabel_length\n");
664
 
-                    logwrite_unlock();
665
 
+                    log_unlock();
666
 
                     }
667
 
                 goto cleanup;
668
 
                }
669
 
@@ -1889,10 +1889,10 @@
670
 
                 substring_issame_case(uindata,offset,len,query);
671
 
             if(return_code_check == JS_ERROR) {
672
 
                 if(rlog_level >= 4) {
673
 
-                    logwrite_lock();
674
 
+                    log_lock();
675
 
                     show_timestamp();
676
 
                     printf("Bad return_code_check\n");
677
 
-                    logwrite_unlock();
678
 
+                    log_unlock();
679
 
                     }
680
 
                 goto cleanup;
681
 
                }
682
 
@@ -1903,28 +1903,28 @@
683
 
                 cname_original_record = get_rtype(query);
684
 
                 if(cname_original_record == JS_ERROR) {
685
 
                     if(rlog_level >= 4) {
686
 
-                        logwrite_lock();
687
 
+                        log_lock();
688
 
                         show_timestamp();
689
 
                         printf("Bad cname_original_record\n");
690
 
-                        logwrite_unlock();
691
 
+                        log_unlock();
692
 
                         }
693
 
                     goto cleanup;
694
 
                    }
695
 
                 if(change_rtype(query,RR_CNAME) == JS_ERROR) {
696
 
                     if(rlog_level >= 4) {
697
 
-                        logwrite_lock();
698
 
+                        log_lock();
699
 
                         show_timestamp();
700
 
                         printf("change_rtype problem\n");
701
 
-                        logwrite_unlock();
702
 
+                        log_unlock();
703
 
                         }
704
 
                     goto cleanup;
705
 
                    }
706
 
                 if(substring_issame_case(uindata,offset,len,query) != 1) {
707
 
                     if(rlog_level >= 4) {
708
 
-                        logwrite_lock();
709
 
+                        log_lock();
710
 
                         show_timestamp();
711
 
                         printf("substring_issame_case problem\n");
712
 
-                        logwrite_unlock();
713
 
+                        log_unlock();
714
 
                         }
715
 
                     goto minus2;
716
 
                    }
717
 
@@ -1944,10 +1944,10 @@
718
 
 
719
 
             if(ttl == JS_ERROR) {
720
 
                 if(rlog_level >= 4) {
721
 
-                    logwrite_lock();
722
 
+                    log_lock();
723
 
                     show_timestamp();
724
 
                     printf("bad ttl\n");
725
 
-                    logwrite_unlock();
726
 
+                    log_unlock();
727
 
                     }
728
 
                 goto minus2;
729
 
                }
730
 
@@ -1967,10 +1967,10 @@
731
 
             rdlength = js_readuint16(uindata,offset);
732
 
             if(rdlength == JS_ERROR) {
733
 
                 if(rlog_level >= 4) {
734
 
-                    logwrite_lock();
735
 
+                    log_lock();
736
 
                     show_timestamp();
737
 
                     printf("bad rdlength\n");
738
 
-                    logwrite_unlock();
739
 
+                    log_unlock();
740
 
                     }
741
 
                 goto minus2;
742
 
                }
743
 
@@ -1984,10 +1984,10 @@
744
 
             /* Determine the IP that the CNAME record points to */
745
 
             if((jsip = js_create(256,1)) == 0) {
746
 
                 if(rlog_level >= 4) {
747
 
-                    logwrite_lock();
748
 
+                    log_lock();
749
 
                     show_timestamp();
750
 
                     printf("bad jsip\n");
751
 
-                    logwrite_unlock();
752
 
+                    log_unlock();
753
 
                     }
754
 
                 goto cleanup;
755
 
                }
756
 
@@ -2008,10 +2008,10 @@
757
 
                        the A record attached to the CNAME */
758
 
                     if(js_copy(spot->data,jsip) == JS_ERROR) {
759
 
                         if(rlog_level >= 4) {
760
 
-                            logwrite_lock();
761
 
+                            log_lock();
762
 
                             show_timestamp();
763
 
                             printf("bad js_copy\n");
764
 
-                            logwrite_unlock();
765
 
+                            log_unlock();
766
 
                             }
767
 
                         goto cleanup_jsip;
768
 
                         }
769
 
@@ -2024,10 +2024,10 @@
770
 
                     if(is_arpa_address == 1) {
771
 
                         if(js_adduint16(jsip,RR_PTR) == JS_ERROR) {
772
 
                             if(rlog_level >= 4) {
773
 
-                                logwrite_lock();
774
 
+                                log_lock();
775
 
                                 show_timestamp();
776
 
                                 printf("bad js_adduint16 RR_PTR\n");
777
 
-                                logwrite_unlock();
778
 
+                                log_unlock();
779
 
                                 }
780
 
                             goto cleanup_jsip;
781
 
                             }
782
 
@@ -2035,12 +2035,12 @@
783
 
                             goto cleanup_jsip;
784
 
                             }
785
 
                         if(rlog_level >= 4) {
786
 
-                            logwrite_lock();
787
 
+                            log_lock();
788
 
                             show_timestamp();
789
 
                             printf("About to recursively chase ptr ");
790
 
                                     show_esc_stdout(jsip);
791
 
                                     printf("\n");
792
 
-                            logwrite_unlock();
793
 
+                            log_unlock();
794
 
                             }
795
 
                         if(recurse_call(0,0,dummy,jsip,0,0,0,ptrq) ==
796
 
                            JS_ERROR) {
797
 
@@ -2052,10 +2052,10 @@
798
 
                     else {
799
 
                         if(js_adduint16(jsip,RR_A) == JS_ERROR) {
800
 
                             if(rlog_level >= 4) {
801
 
-                                logwrite_lock();
802
 
+                                log_lock();
803
 
                                 show_timestamp();
804
 
                                 printf("bad js_adduint16 RR_A\n");
805
 
-                                logwrite_unlock();
806
 
+                                log_unlock();
807
 
                                 }
808
 
                             goto cleanup_jsip;
809
 
                             }
810
 
@@ -2092,10 +2092,10 @@
811
 
             if(cname_original_record != 0) {
812
 
                 if(change_rtype(query,cname_original_record) == JS_ERROR) {
813
 
                     if(rlog_level >= 4) {
814
 
-                        logwrite_lock();
815
 
+                        log_lock();
816
 
                         show_timestamp();
817
 
                         printf("bad change_rtype return code\n");
818
 
-                        logwrite_unlock();
819
 
+                        log_unlock();
820
 
                         }
821
 
                     goto cleanup;
822
 
                    }
823
 
@@ -2556,13 +2556,13 @@
824
 
     tcount_unlock();
825
 
 
826
 
     if(rlog_level >= 4) {
827
 
-        logwrite_lock();
828
 
+        log_lock();
829
 
         show_timestamp();
830
 
        tcount_lock();
831
 
         printf("In thread; ready to begin recursion; Threads in use: %d\n",
832
 
        num_of_threads_running);
833
 
        tcount_unlock();
834
 
-        logwrite_unlock();
835
 
+        log_unlock();
836
 
         }
837
 
 
838
 
     do_big_lock();
839
 
@@ -2571,13 +2571,13 @@
840
 
     big_unlock();
841
 
 
842
 
     if(rlog_level >= 4) {
843
 
-        logwrite_lock();
844
 
+        log_lock();
845
 
         show_timestamp();
846
 
        tcount_lock();
847
 
         printf("Ready to terminate thread; threads in use %d\n",
848
 
        num_of_threads_running);
849
 
        tcount_unlock();
850
 
-        logwrite_unlock();
851
 
+        log_unlock();
852
 
         }
853
 
 
854
 
     js_destroy(req->query);
855
 
@@ -2626,11 +2626,11 @@
856
 
     if(queries_sent > max_queries_total ||
857
 
        glueless_level > max_glueless_level) {
858
 
         if(rlog_level >= 4) {
859
 
-            logwrite_lock();
860
 
+            log_lock();
861
 
             show_timestamp();
862
 
             show_esc_stdout(query);
863
 
             printf(" queries_total/glueless_level exceeded\n");
864
 
-            logwrite_unlock();
865
 
+            log_unlock();
866
 
             }
867
 
         return JS_ERROR;
868
 
         }
869
 
@@ -2654,11 +2654,11 @@
870
 
     qtype = get_rtype(query);
871
 
     if(qtype == RR_ANY) {
872
 
         if(rlog_level >= 4) {
873
 
-            logwrite_lock();
874
 
+            log_lock();
875
 
             show_timestamp();
876
 
             show_esc_stdout(query);
877
 
             printf(" is an ANY query\n");
878
 
-            logwrite_unlock();
879
 
+            log_unlock();
880
 
             }
881
 
         /* Make sure the RR_A and RR_NS are placed in the dns cache */
882
 
         change_rtype(query,RR_A);
883
 
@@ -2703,12 +2703,12 @@
884
 
 
885
 
     /* Look for query in cache */
886
 
     if(rlog_level >= 4) {
887
 
-        logwrite_lock();
888
 
+        log_lock();
889
 
         show_timestamp();
890
 
         printf("Looking for ");
891
 
         show_esc_stdout(lower);
892
 
         printf(" in cache\n");
893
 
-        logwrite_unlock();
894
 
+        log_unlock();
895
 
         }
896
 
     spot_data = mhash_get(dnscache,lower);
897
 
 
898
 
@@ -2716,11 +2716,11 @@
899
 
        answer */
900
 
     if(spot_data.value != 0 && spot_data.datatype == MARA_DNS_NEG) {
901
 
         if(rlog_level >= 4) {
902
 
-            logwrite_lock();
903
 
+            log_lock();
904
 
             show_timestamp();
905
 
             show_esc_stdout(lower);
906
 
             printf(" found in cache (psudo-NXDOMAIN) at %p\n",spot_data.value);
907
 
-            logwrite_unlock();
908
 
+            log_unlock();
909
 
             }
910
 
         if(give_answer(spot_data.value,spot_data.datatype,spot_data.point,
911
 
                        ipret,ptrret,query,lower,id,sock,client,queries_sent,
912
 
@@ -2732,11 +2732,11 @@
913
 
     /* Return cached data if found */
914
 
     if(spot_data.value != 0 && spot_data.datatype == MARA_DNSRR) {
915
 
         if(rlog_level >= 4) {
916
 
-            logwrite_lock();
917
 
+            log_lock();
918
 
             show_timestamp();
919
 
             show_esc_stdout(lower);
920
 
             printf(" found in cache (RR) at %p\n",spot_data.value);
921
 
-            logwrite_unlock();
922
 
+            log_unlock();
923
 
             }
924
 
         if(give_answer(spot_data.value,spot_data.datatype,spot_data.point,
925
 
                        ipret,ptrret,query,lower,id,sock,client,queries_sent,
926
 
@@ -2753,11 +2753,11 @@
927
 
     spot_data = mhash_get(dnscache,copy);
928
 
     if(spot_data.value != 0 && spot_data.datatype == MARA_DNSRR) {
929
 
         if(rlog_level >= 4) {
930
 
-            logwrite_lock();
931
 
+            log_lock();
932
 
             show_timestamp();
933
 
             show_esc_stdout(lower);
934
 
             printf(" found in cache (CNAME RR) at %p\n",spot_data.value);
935
 
-            logwrite_unlock();
936
 
+            log_unlock();
937
 
             }
938
 
         if(give_answer(spot_data.value,spot_data.datatype,spot_data.point,
939
 
                        ipret,ptrret,query,
940
 
@@ -2769,11 +2769,11 @@
941
 
 
942
 
 
943
 
     if(rlog_level >= 4) {
944
 
-        logwrite_lock();
945
 
+        log_lock();
946
 
         show_timestamp();
947
 
         show_esc_stdout(lower);
948
 
         printf(" not found in cache\n");
949
 
-        logwrite_unlock();
950
 
+        log_unlock();
951
 
         }
952
 
 
953
 
     /* If we still haven't found something, perhaps a lower-case version of
954
 
@@ -2782,12 +2782,12 @@
955
 
     /* If we could fold the case, look for a lower-case version of the same */
956
 
     if(case_folded == 1) {
957
 
         if(rlog_level >= 4) {
958
 
-            logwrite_lock();
959
 
+            log_lock();
960
 
             show_timestamp();
961
 
             printf("Looking for ");
962
 
             show_esc_stdout(lower);
963
 
             printf(" (lowercase)\n");
964
 
-            logwrite_unlock();
965
 
+            log_unlock();
966
 
             }
967
 
         spot_data = mhash_get(dnscache,lower);
968
 
 
969
 
@@ -2795,12 +2795,12 @@
970
 
            answer */
971
 
         if(spot_data.value != 0 && spot_data.datatype == MARA_DNS_NEG) {
972
 
             if(rlog_level >= 4) {
973
 
-                logwrite_lock();
974
 
+                log_lock();
975
 
                 show_timestamp();
976
 
                 show_esc_stdout(lower);
977
 
                 printf(" found (lowercase psudo-NXDOMAIN) at %p\n",
978
 
                        spot_data.value);
979
 
-                logwrite_unlock();
980
 
+                log_unlock();
981
 
                 }
982
 
             if(give_answer(spot_data.value,spot_data.datatype,
983
 
                        spot_data.point,ipret,ptrret,query,
984
 
@@ -2813,11 +2813,11 @@
985
 
         /* Return cached data if found */
986
 
         if(spot_data.value != 0 && spot_data.datatype == MARA_DNSRR) {
987
 
             if(rlog_level >= 4) {
988
 
-                logwrite_lock();
989
 
+                log_lock();
990
 
                 show_timestamp();
991
 
                 show_esc_stdout(lower);
992
 
                 printf(" found (lowercase RR) at %p\n",spot_data.value);
993
 
-                logwrite_unlock();
994
 
+                log_unlock();
995
 
                 }
996
 
             if(give_answer(spot_data.value,spot_data.datatype,
997
 
                        spot_data.point,ipret,ptrret,query,
998
 
@@ -2836,11 +2836,11 @@
999
 
         spot_data = mhash_get(dnscache,copy);
1000
 
         if(spot_data.value != 0 && spot_data.datatype == MARA_DNSRR) {
1001
 
             if(rlog_level >= 4) {
1002
 
-                logwrite_lock();
1003
 
+                log_lock();
1004
 
                 show_timestamp();
1005
 
                 show_esc_stdout(lower);
1006
 
                 printf(" found (CNAME lowercase RR) at %p\n",spot_data.value);
1007
 
-                logwrite_unlock();
1008
 
+                log_unlock();
1009
 
                 }
1010
 
             if(give_answer(spot_data.value,spot_data.datatype,spot_data.point,
1011
 
                        ipret,ptrret,query,copy,id,sock,client,queries_sent,
1012
 
@@ -2850,11 +2850,11 @@
1013
 
             }
1014
 
 
1015
 
         if(rlog_level >= 4) {
1016
 
-            logwrite_lock();
1017
 
+            log_lock();
1018
 
             show_timestamp();
1019
 
             show_esc_stdout(lower);
1020
 
             printf(" not found in cache either\n");
1021
 
-            logwrite_unlock();
1022
 
+            log_unlock();
1023
 
             }
1024
 
 
1025
 
         }
1026
 
@@ -2872,12 +2872,12 @@
1027
 
        the data we are seeking */
1028
 
     do {
1029
 
         if(rlog_level >= 4) {
1030
 
-            logwrite_lock();
1031
 
+            log_lock();
1032
 
             show_timestamp();
1033
 
             printf("Looking for ");
1034
 
             show_esc_stdout(copy);
1035
 
             printf(" in cache (NS referral)\n");
1036
 
-            logwrite_unlock();
1037
 
+            log_unlock();
1038
 
             }
1039
 
 
1040
 
         spot_data = mhash_get(dnscache,copy);
1041
 
@@ -2889,12 +2889,12 @@
1042
 
             js_copy(copy,lower);
1043
 
             if(fold_case(lower) == JS_SUCCESS) { /* If we can fold the case */
1044
 
                 if(rlog_level >= 4) {
1045
 
-                    logwrite_lock();
1046
 
+                    log_lock();
1047
 
                     show_timestamp();
1048
 
                     printf("Looking for ");
1049
 
                     show_esc_stdout(lower);
1050
 
                     printf(" in cache (lowercase NS ref)\n");
1051
 
-                    logwrite_unlock();
1052
 
+                    log_unlock();
1053
 
                     }
1054
 
                 spot_data = mhash_get(dnscache,lower);
1055
 
                 if(spot_data.value != 0 && spot_data.datatype == MARA_DNS_NS)
1056
 
@@ -2906,14 +2906,14 @@
1057
 
         if(spot_data.value != 0 && spot_data.datatype == MARA_DNS_NS) {
1058
 
             cpoint = spot_data.value;
1059
 
             if(rlog_level >= 4) {
1060
 
-                logwrite_lock();
1061
 
+                log_lock();
1062
 
                 show_timestamp();
1063
 
                 if(case_folded_found == 1)
1064
 
                     show_esc_stdout(lower);
1065
 
                 else
1066
 
                     show_esc_stdout(copy);
1067
 
                 printf(" found at %p\n",spot_data.value);
1068
 
-                logwrite_unlock();
1069
 
+                log_unlock();
1070
 
                 }
1071
 
             move_to_top(cpoint->zap);
1072
 
             /* If the data expires (is not 0), and the data has expired... */
1073
 
@@ -2922,14 +2922,14 @@
1074
 
                 /* Make the read-only lock a read-write lock */
1075
 
 
1076
 
                 if(rlog_level >= 4) {
1077
 
-                   logwrite_lock();
1078
 
+                   log_lock();
1079
 
                     show_timestamp();
1080
 
                     if(case_folded_found == 1)
1081
 
                         show_esc_stdout(lower);
1082
 
                     else
1083
 
                         show_esc_stdout(copy);
1084
 
                     printf(" at %p has expired, zapping\n",spot_data.value);
1085
 
-                   logwrite_unlock();
1086
 
+                   log_unlock();
1087
 
                     }
1088
 
 
1089
 
                 if(case_folded_found == 0)
1090
 
@@ -2950,7 +2950,7 @@
1091
 
                original */
1092
 
 
1093
 
             if(rlog_level >= 4) {
1094
 
-                logwrite_lock();
1095
 
+                log_lock();
1096
 
                 show_timestamp();
1097
 
                 printf("Making cpoint copy of ");
1098
 
                 if(case_folded_found == 1)
1099
 
@@ -2958,7 +2958,7 @@
1100
 
                 else
1101
 
                     show_esc_stdout(copy);
1102
 
                 printf(" at %p\n",spot_data.value);
1103
 
-                logwrite_unlock();
1104
 
+                log_unlock();
1105
 
                 }
1106
 
 
1107
 
             if((local_c = js_alloc(1,sizeof(closer))) == 0)
1108
 
@@ -3217,22 +3217,22 @@
1109
 
        set up and launch a thread. */
1110
 
     do_big_lock();
1111
 
     if(rlog_level >= 4) {
1112
 
-        logwrite_lock();
1113
 
+        log_lock();
1114
 
         show_timestamp();
1115
 
         printf("Looking for ");
1116
 
         show_esc_stdout(query);
1117
 
         printf(" in DNS cache\n");
1118
 
-        logwrite_unlock();
1119
 
+        log_unlock();
1120
 
         }
1121
 
     spot_data = mhash_get(dnscache,query);
1122
 
     if(spot_data.value != 0 && (spot_data.datatype == MARA_DNSRR ||
1123
 
        spot_data.datatype == MARA_DNS_NEG)) {
1124
 
         if(rlog_level >= 4) {
1125
 
-            logwrite_lock();
1126
 
+            log_lock();
1127
 
             show_timestamp();
1128
 
             show_esc_stdout(query);
1129
 
             printf(" found at %p\n",spot_data.value);
1130
 
-            logwrite_unlock();
1131
 
+            log_unlock();
1132
 
             }
1133
 
         lookatrr = spot_data.value;
1134
 
         move_to_top(lookatrr->zap);
1135
 
@@ -3244,20 +3244,20 @@
1136
 
            INCOMPLETE_CNAME_LIFETIME))) {
1137
 
             /* Do almost nothing */
1138
 
             if(rlog_level >= 4) {
1139
 
-               logwrite_lock();
1140
 
+               log_lock();
1141
 
                 show_timestamp();
1142
 
                 show_esc_stdout(query);
1143
 
                 printf(" has expired at %p\n",spot_data.value);
1144
 
-               logwrite_unlock();
1145
 
+               log_unlock();
1146
 
                 }
1147
 
             }
1148
 
         else if(spot_data.datatype == MARA_DNS_NEG) {
1149
 
             if(rlog_level >= 4) {
1150
 
-               logwrite_lock();
1151
 
+               log_lock();
1152
 
                 show_timestamp();
1153
 
                 show_esc_stdout(query);
1154
 
                 printf(" is a psudo-NXDOMAIN at %p\n",spot_data.value);
1155
 
-               logwrite_unlock();
1156
 
+               log_unlock();
1157
 
                 }
1158
 
             udpnotfound(lookatrr,id,sock,&client,query,0,1,0,1);
1159
 
            big_unlock();
1160
 
@@ -3265,11 +3265,11 @@
1161
 
             }
1162
 
         else {
1163
 
             if(rlog_level >= 4) {
1164
 
-               logwrite_lock();
1165
 
+               log_lock();
1166
 
                 show_timestamp();
1167
 
                 show_esc_stdout(query);
1168
 
                 printf(" is an RR at %p\n",spot_data.value);
1169
 
-               logwrite_unlock();
1170
 
+               log_unlock();
1171
 
                 }
1172
 
             udpsuccess(spot_data.value,id,sock,&client,query,
1173
 
                        spot_data.point,0,1,0);
1174
 
@@ -3279,11 +3279,11 @@
1175
 
         }
1176
 
     else {
1177
 
         if(rlog_level >= 4) {
1178
 
-            logwrite_lock();
1179
 
+            log_lock();
1180
 
             show_timestamp();
1181
 
             show_esc_stdout(query);
1182
 
             printf(" not found in cache\n");
1183
 
-            logwrite_unlock();
1184
 
+            log_unlock();
1185
 
             }
1186
 
         }
1187
 
 
1188
 
@@ -3301,12 +3301,12 @@
1189
 
             return JS_ERROR;
1190
 
             }
1191
 
         if(rlog_level >= 4) {
1192
 
-            logwrite_lock();
1193
 
+            log_lock();
1194
 
             show_timestamp();
1195
 
             printf("Looking for ");
1196
 
             show_esc_stdout(query);
1197
 
             printf(" in DNS cache (CNAME lookup)\n");
1198
 
-            logwrite_unlock();
1199
 
+            log_unlock();
1200
 
             }
1201
 
         spot_data = mhash_get(dnscache,query);
1202
 
         if(spot_data.value != 0 && (spot_data.datatype == MARA_DNSRR ||
1203
 
@@ -3321,21 +3321,21 @@
1204
 
                INCOMPLETE_CNAME_LIFETIME))) {
1205
 
                 /* Do almost nothing */
1206
 
                 if(rlog_level >= 4) {
1207
 
-                    logwrite_lock();
1208
 
+                    log_lock();
1209
 
                     show_timestamp();
1210
 
                     show_esc_stdout(query);
1211
 
                     printf(" has expired (CNAME) at %p\n",spot_data.value);
1212
 
-                    logwrite_unlock();
1213
 
+                    log_unlock();
1214
 
                     }
1215
 
                 }
1216
 
             else if(spot_data.datatype == MARA_DNS_NEG) {
1217
 
                 if(rlog_level >= 4) {
1218
 
-                    logwrite_lock();
1219
 
+                    log_lock();
1220
 
                     show_timestamp();
1221
 
                     show_esc_stdout(query);
1222
 
                     printf(" is a psudo-NXDOMAIN (CNAME) at %p\n",
1223
 
                            spot_data.value);
1224
 
-                    logwrite_unlock();
1225
 
+                    log_unlock();
1226
 
                     }
1227
 
                 udpnotfound(lookatrr,id,sock,&client,query,0,1,0,1);
1228
 
                 big_unlock();
1229
 
@@ -3343,11 +3343,11 @@
1230
 
                 }
1231
 
             else {
1232
 
                 if(rlog_level >= 4) {
1233
 
-                    logwrite_lock();
1234
 
+                    log_lock();
1235
 
                     show_timestamp();
1236
 
                     show_esc_stdout(query);
1237
 
                     printf(" is an RR (CNAME) at %p\n",spot_data.value);
1238
 
-                    logwrite_unlock();
1239
 
+                    log_unlock();
1240
 
                     }
1241
 
                 if(change_rtype(query,original_rtype) == JS_ERROR) {
1242
 
                     big_unlock();
1243
 
@@ -3365,11 +3365,11 @@
1244
 
             }
1245
 
         else {
1246
 
             if(rlog_level >= 4) {
1247
 
-                logwrite_lock();
1248
 
+                log_lock();
1249
 
                 show_timestamp();
1250
 
                 show_esc_stdout(query);
1251
 
                 printf(" not found in cache (CNAME)\n");
1252
 
-                logwrite_unlock();
1253
 
+                log_unlock();
1254
 
                 }
1255
 
             }
1256
 
         }
1257
 
@@ -3379,10 +3379,10 @@
1258
 
         return JS_ERROR;
1259
 
 
1260
 
     if(rlog_level >= 4) {
1261
 
-        logwrite_lock();
1262
 
+        log_lock();
1263
 
         show_timestamp();
1264
 
         printf("initializing thread\n");
1265
 
-        logwrite_unlock();
1266
 
+        log_unlock();
1267
 
         }
1268
 
 
1269
 
     /* We need to create some thread-safe data structures.
1270
 
@@ -3418,10 +3418,10 @@
1271
 
         tcount_unlock();
1272
 
         js_dealloc(req); js_destroy(copy);
1273
 
         if(rlog_level >= 4) {
1274
 
-            logwrite_lock();
1275
 
+            log_lock();
1276
 
             show_timestamp();
1277
 
             printf("too many threads running\n");
1278
 
-            logwrite_unlock();
1279
 
+            log_unlock();
1280
 
             }
1281
 
         /* Return a "server fail" error message if we can not spawn
1282
 
            a thread.  We need to synthesize a header to do this */
1283
 
@@ -3444,10 +3444,10 @@
1284
 
     recurse_thread(req);
1285
 
 #else
1286
 
     if(rlog_level >= 4) {
1287
 
-        logwrite_lock();
1288
 
+        log_lock();
1289
 
         show_timestamp();
1290
 
         printf("About to launch thread...\n");
1291
 
-        logwrite_unlock();
1292
 
+        log_unlock();
1293
 
         }
1294
 
     /* Set up the attributes for the thread.  Make this a detached
1295
 
        thread because we don't look at the return value (the thread
1296
 
@@ -3535,12 +3535,12 @@
1297
 
     /* Add the data to the hash */
1298
 
 
1299
 
     if(rlog_level >= 4) {
1300
 
-       logwrite_lock();
1301
 
+       log_lock();
1302
 
         show_timestamp();
1303
 
         printf("Adding ");
1304
 
         show_esc_stdout(zone);
1305
 
         printf(" to cache at %p (jsddip)\n",close);
1306
 
-       logwrite_unlock();
1307
 
+       log_unlock();
1308
 
         }
1309
 
 
1310
 
     /* See if the data is already there.  If so, act based on the value
1311
 
@@ -3576,10 +3576,10 @@
1312
 
                     point = point->next;
1313
 
                 point->next = close;
1314
 
                 if(rlog_level >= 4) {
1315
 
-                   logwrite_lock();
1316
 
+                   log_lock();
1317
 
                     show_timestamp();
1318
 
                     printf("That's an append\n");
1319
 
-                   logwrite_unlock();
1320
 
+                   log_unlock();
1321
 
                     }
1322
 
                 return JS_SUCCESS;
1323
 
 
1324
 
@@ -3651,12 +3651,12 @@
1325
 
     /* Add the data to the hash */
1326
 
 
1327
 
     if(rlog_level >= 4) {
1328
 
-       logwrite_lock();
1329
 
+       log_lock();
1330
 
         show_timestamp();
1331
 
         printf("Adding ");
1332
 
         show_esc_stdout(zone);
1333
 
         printf(" to cache at %p (ipv4pair)\n",close);
1334
 
-       logwrite_unlock();
1335
 
+       log_unlock();
1336
 
         }
1337
 
 
1338
 
     /* See if the data is already there.  If so, act based on the value
1339
 
@@ -3692,10 +3692,10 @@
1340
 
                     point = point->next;
1341
 
                 point->next = close;
1342
 
                 if(rlog_level >= 4) {
1343
 
-                   logwrite_lock();
1344
 
+                   log_lock();
1345
 
                     show_timestamp();
1346
 
                     printf("That's an append\n");
1347
 
-                   logwrite_unlock();
1348
 
+                   log_unlock();
1349
 
                     }
1350
 
                 return JS_SUCCESS;
1351
 
             /* XXX to do: mask */
1352
 
@@ -3772,12 +3772,12 @@
1353
 
     close->zap = 0;
1354
 
 
1355
 
     if(rlog_level >= 4) {
1356
 
-       logwrite_lock();
1357
 
+       log_lock();
1358
 
         show_timestamp();
1359
 
         printf("Adding ");
1360
 
         show_esc_stdout(zone);
1361
 
         printf(" to cache at %p (js)\n",close);
1362
 
-       logwrite_unlock();
1363
 
+       log_unlock();
1364
 
         }
1365
 
 
1366
 
     /* Add the data to the hash */
1367
 
@@ -3805,10 +3805,10 @@
1368
 
                     point = point->next;
1369
 
                 point->next = close;
1370
 
                 if(rlog_level >= 4) {
1371
 
-                   logwrite_lock();
1372
 
+                   log_lock();
1373
 
                     show_timestamp();
1374
 
                     printf("That's an append\n");
1375
 
-                   logwrite_unlock();
1376
 
+                   log_unlock();
1377
 
                     }
1378
 
                 js_destroy(zone_copy);
1379
 
                 return JS_SUCCESS;
1380
 
@@ -3996,12 +3996,12 @@
1381
 
     close->zap = 0;
1382
 
 
1383
 
     if(rlog_level >= 4) {
1384
 
-       logwrite_lock();
1385
 
+       log_lock();
1386
 
         show_timestamp();
1387
 
         printf("Adding ");
1388
 
         show_esc_stdout(zone);
1389
 
         printf(" to cache at %p (jsip)\n",close);
1390
 
-       logwrite_unlock();
1391
 
+       log_unlock();
1392
 
         }
1393
 
 
1394
 
     /* Add the data to the hash */
1395
 
--- maradns-1.2.06.orig/server/functions_server.h       2006-03-10 00:53:39.000000000 -0800
1396
 
+++ maradns-1.2.06/server/functions_server.h    2006-03-10 00:56:26.000000000 -0800
1397
 
@@ -273,3 +273,10 @@
1398
 
 
1399
 
 int init_handle_noreply(int value);
1400
 
 
1401
 
+#ifndef AUTHONLY
1402
 
+/* Lock the writing of log messages */
1403
 
+void log_lock();
1404
 
+void log_unlock();
1405
 
+#endif /* AUTHONLY */
1406
 
+
1407
 
+