« back to all changes in this revision
Viewing changes to dlib/tostring.c
- browse files at revision 4
- compare with another revision
- download diff
- download tarball
- view history from revision 4
- Committer: Bazaar Package Importer
- Author(s): Thijs Kinkhorst
- Date: 2006-10-19 12:09:39 UTC
- mfrom: (3.1.1 dapper)
- Revision ID: james.westby@ubuntu.com-20061019120939-t818x24e2tn8be5k
Tags: 1.1.18-2.1
* Non-maintainer upload for RC bug.
* Make sure changelogs are installed into all packages (Closes: #393568).
* Make sure changelogs are installed into all packages (Closes: #393568).
- files added:
- README.latest
- files removed:
- acconfig.h
- files modified:
- BUGS
added
removed
dlib/tostring.c
1
/*
2
* Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2003
3
* Inferno Nettverk A/S, Norway. All rights reserved.
4
*
5
* Redistribution and use in source and binary forms, with or without
6
* modification, are permitted provided that the following conditions
7
* are met:
8
* 1. The above copyright notice, this list of conditions and the following
9
* disclaimer must appear in all copies of the software, derivative works
10
* or modified versions, and any portions thereof, aswell as in all
11
* supporting documentation.
12
* 2. All advertising materials mentioning features or use of this software
13
* must display the following acknowledgement:
14
* This product includes software developed by
15
* Inferno Nettverk A/S, Norway.
16
* 3. The name of the author may not be used to endorse or promote products
17
* derived from this software without specific prior written permission.
18
*
19
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
*
30
* Inferno Nettverk A/S requests users of this software to return to
31
*
32
* Software Distribution Coordinator or sdc@inet.no
33
* Inferno Nettverk A/S
34
* Oslo Research Park
35
* Gaustadall�en 21
36
* NO-0349 Oslo
37
* Norway
38
*
39
* any improvements or extensions that they make and grant Inferno Nettverk A/S
40
* the rights to redistribute these changes.
41
*
42
*/
43
44
#include "common.h"
45
#include "config_parse.h"
46
47
static const char rcsid[] =
48
"$Id: tostring.c,v 1.9 2003/07/01 13:21:32 michaels Exp $";
49
50
char *
51
proxyprotocols2string(proxyprotocols, str, strsize)
52
const struct proxyprotocol_t *proxyprotocols;
53
char *str;
54
size_t strsize;
55
{
56
size_t strused;
57
58
if (strsize)
59
*str = NUL; /* make sure we return a NUL terminated string. */
60
else
61
return str;
62
63
strused = 0;
64
65
if (proxyprotocols->socks_v4)
66
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
67
QUOTE(SOCKS_V4s));
68
69
if (proxyprotocols->socks_v5)
70
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
71
QUOTE(SOCKS_V5s));
72
73
if (proxyprotocols->msproxy_v2)
74
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
75
QUOTE(MSPROXY_V2s));
76
77
if (proxyprotocols->http_v1_0)
78
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
79
QUOTE(HTTP_V1_0s));
80
81
return str;
82
}
83
84
char *
85
protocols2string(protocols, str, strsize)
86
const struct protocol_t *protocols;
87
char *str;
88
size_t strsize;
89
{
90
size_t strused;
91
92
if (strsize)
93
*str = NUL; /* make sure we return a NUL terminated string. */
94
else
95
return str;
96
97
strused = 0;
98
99
if (protocols->tcp)
100
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
101
QUOTE(PROTOCOL_TCPs));
102
103
if (protocols->udp)
104
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
105
QUOTE(PROTOCOL_UDPs));
106
107
return str;
108
}
109
110
111
const char *
112
socks_packet2string(packet, type)
113
const void *packet;
114
int type;
115
{
116
static char buf[1024];
117
char hstring[MAXSOCKSHOSTSTRING];
118
unsigned char version;
119
const struct request_t *request = NULL;
120
const struct response_t *response = NULL;
121
122
switch (type) {
123
case SOCKS_REQUEST:
124
request = (const struct request_t *)packet;
125
version = request->version;
126
break;
127
128
case SOCKS_RESPONSE:
129
response = (const struct response_t *)packet;
130
version = response->version;
131
break;
132
133
default:
134
SERRX(type);
135
}
136
137
switch (version) {
138
case SOCKS_V4:
139
case SOCKS_V4REPLY_VERSION:
140
switch (type) {
141
case SOCKS_REQUEST:
142
snprintfn(buf, sizeof(buf),
143
"(V4) VN: %d CD: %d address: %s",
144
request->version, request->command,
145
sockshost2string(&request->host, hstring, sizeof(hstring)));
146
break;
147
148
case SOCKS_RESPONSE:
149
snprintfn(buf, sizeof(buf), "(V4) VN: %d CD: %d address: %s",
150
response->version, response->reply,
151
sockshost2string(&response->host, hstring, sizeof(hstring)));
152
break;
153
}
154
break;
155
156
case SOCKS_V5:
157
switch (type) {
158
case SOCKS_REQUEST:
159
snprintfn(buf, sizeof(buf),
160
"VER: %d CMD: %d FLAG: %d ATYP: %d address: %s",
161
request->version, request->command, request->flag,
162
request->host.atype,
163
sockshost2string(&request->host, hstring, sizeof(hstring)));
164
break;
165
166
case SOCKS_RESPONSE:
167
snprintfn(buf, sizeof(buf),
168
"VER: %d REP: %d FLAG: %d ATYP: %d address: %s",
169
response->version, response->reply, response->flag,
170
response->host.atype,
171
sockshost2string(&response->host, hstring, sizeof(hstring)));
172
break;
173
}
174
break;
175
176
default:
177
SERRX(version);
178
}
179
180
return buf;
181
}
182
183
184
enum operator_t
185
string2operator(string)
186
const char *string;
187
{
188
189
if (strcmp(string, "eq") == 0 || strcmp(string, "=") == 0)
190
return eq;
191
192
if (strcmp(string, "neq") == 0 || strcmp(string, "!=") == 0)
193
return neq;
194
195
if (strcmp(string, "ge") == 0 || strcmp(string, ">=") == 0)
196
return ge;
197
198
if (strcmp(string, "le") == 0 || strcmp(string, "<=") == 0)
199
return le;
200
201
if (strcmp(string, "gt") == 0 || strcmp(string, ">") == 0)
202
return gt;
203
204
if (strcmp(string, "lt") == 0 || strcmp(string, "<") == 0)
205
return lt;
206
207
/* parser should make sure this never happens. */
208
SERRX(string);
209
210
/* NOTREACHED */
211
}
212
213
214
215
const char *
216
operator2string(operator)
217
enum operator_t operator;
218
{
219
220
switch (operator) {
221
case none:
222
return QUOTE("none");
223
224
case eq:
225
return QUOTE("eq");
226
227
case neq:
228
return QUOTE("neq");
229
230
case ge:
231
return QUOTE("ge");
232
233
case le:
234
return QUOTE("le");
235
236
case gt:
237
return QUOTE("gt");
238
239
case lt:
240
return QUOTE("lt");
241
242
case range:
243
return QUOTE("range");
244
245
default:
246
SERRX(operator);
247
}
248
249
/* NOTREACHED */
250
}
251
252
253
const char *
254
ruleaddress2string(address, string, len)
255
const struct ruleaddress_t *address;
256
char *string;
257
size_t len;
258
{
259
260
/* for debugging. */
261
if (string == NULL) {
262
static char addrstring[MAXRULEADDRSTRING];
263
264
string = addrstring;
265
len = sizeof(addrstring);
266
}
267
268
switch (address->atype) {
269
case SOCKS_ADDR_IPV4: {
270
char *a;
271
272
snprintfn(string, len,
273
"%s: %s/%d, %s: %d, %s : %d, %s: %s, %s: %d",
274
QUOTE("address"),
275
QUOTE(strcheck(a = strdup(inet_ntoa(address->addr.ipv4.ip)))),
276
QUOTE(bitcount((unsigned long)address->addr.ipv4.mask.s_addr)),
277
QUOTE("tcp"),
278
QUOTE(ntohs(address->port.tcp)),
279
QUOTE("udp"),
280
QUOTE(ntohs(address->port.udp)),
281
QUOTE("op"),
282
QUOTE(operator2string(address->operator)),
283
QUOTE("end"),
284
QUOTE(ntohs(address->portend)));
285
free(a);
286
break;
287
}
288
289
case SOCKS_ADDR_DOMAIN:
290
snprintfn(string, len,
291
"%s: %s, %s: %d, %s : %d, %s: %s, %s: %d",
292
QUOTE("address"),
293
QUOTE(address->addr.domain),
294
QUOTE("tcp"),
295
QUOTE(ntohs(address->port.tcp)),
296
QUOTE("udp"),
297
QUOTE(ntohs(address->port.udp)),
298
QUOTE("op"),
299
QUOTE(operator2string(address->operator)),
300
QUOTE("end"),
301
QUOTE(ntohs(address->portend)));
302
break;
303
304
case SOCKS_ADDR_IFNAME:
305
snprintfn(string, len,
306
"%s: %s, %s: %d, %s : %d, %s: %s, %s: %d",
307
QUOTE("address"),
308
QUOTE(address->addr.ifname),
309
QUOTE("tcp"),
310
QUOTE(ntohs(address->port.tcp)),
311
QUOTE("udp"),
312
QUOTE(ntohs(address->port.udp)),
313
QUOTE("op"),
314
QUOTE(operator2string(address->operator)),
315
QUOTE("end"),
316
QUOTE(ntohs(address->portend)));
317
break;
318
319
default:
320
SERRX(address->atype);
321
}
322
323
return string;
324
}
325
326
327
const char *
328
protocol2string(protocol)
329
int protocol;
330
{
331
332
switch (protocol) {
333
case SOCKS_TCP:
334
return QUOTE(PROTOCOL_TCPs);
335
336
case SOCKS_UDP:
337
return QUOTE(PROTOCOL_UDPs);
338
339
default:
340
SERRX(protocol);
341
}
342
343
/* NOTREACHED */
344
}
345
346
const char *
347
resolveprotocol2string(resolveprotocol)
348
int resolveprotocol;
349
{
350
switch (resolveprotocol) {
351
case RESOLVEPROTOCOL_TCP:
352
return QUOTE(PROTOCOL_TCPs);
353
354
case RESOLVEPROTOCOL_UDP:
355
return QUOTE(PROTOCOL_UDPs);
356
357
case RESOLVEPROTOCOL_FAKE:
358
return QUOTE("fake");
359
360
default:
361
SERRX(resolveprotocol);
362
}
363
364
/* NOTREACHED */
365
}
366
367
368
const char *
369
command2string(command)
370
int command;
371
{
372
373
switch (command) {
374
case SOCKS_BIND:
375
return QUOTE(SOCKS_BINDs);
376
377
case SOCKS_CONNECT:
378
return QUOTE(SOCKS_CONNECTs);
379
380
case SOCKS_UDPASSOCIATE:
381
return QUOTE(SOCKS_UDPASSOCIATEs);
382
383
/* pseudo commands. */
384
case SOCKS_ACCEPT:
385
return QUOTE(SOCKS_ACCEPTs);
386
387
case SOCKS_BINDREPLY:
388
return QUOTE(SOCKS_BINDREPLYs);
389
390
case SOCKS_UDPREPLY:
391
return QUOTE(SOCKS_UDPREPLYs);
392
393
case SOCKS_DISCONNECT:
394
return QUOTE(SOCKS_DISCONNECTs);
395
396
default:
397
SERRX(command);
398
}
399
400
/* NOTREACHED */
401
}
402
403
char *
404
commands2string(command, str, strsize)
405
const struct command_t *command;
406
char *str;
407
size_t strsize;
408
{
409
size_t strused;
410
411
if (strsize)
412
*str = NUL; /* make sure we return a NUL terminated string. */
413
else
414
return str;
415
416
strused = 0;
417
418
if (command->bind)
419
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
420
command2string(SOCKS_BIND));
421
422
if (command->bindreply)
423
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
424
command2string(SOCKS_BINDREPLY));
425
426
if (command->connect)
427
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
428
command2string(SOCKS_CONNECT));
429
430
if (command->udpassociate)
431
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
432
command2string(SOCKS_UDPASSOCIATE));
433
434
if (command->udpreply)
435
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
436
command2string(SOCKS_UDPREPLY));
437
438
return str;
439
}
440
441
const char *
442
method2string(method)
443
int method;
444
{
445
446
switch (method) {
447
case AUTHMETHOD_NONE:
448
return QUOTE(AUTHMETHOD_NONEs);
449
450
case AUTHMETHOD_GSSAPI:
451
return QUOTE(AUTHMETHOD_GSSAPIs);
452
453
case AUTHMETHOD_UNAME:
454
return QUOTE(AUTHMETHOD_UNAMEs);
455
456
case AUTHMETHOD_NOACCEPT:
457
return QUOTE(AUTHMETHOD_NOACCEPTs);
458
459
case AUTHMETHOD_RFC931:
460
return QUOTE(AUTHMETHOD_RFC931s);
461
462
case AUTHMETHOD_PAM:
463
return QUOTE(AUTHMETHOD_PAMs);
464
465
default:
466
SERRX(method);
467
}
468
469
/* NOTREACHED */
470
}
471
472
char *
473
methods2string(methodc, methodv, str, strsize)
474
size_t methodc;
475
const int *methodv;
476
char *str;
477
size_t strsize;
478
{
479
size_t strused;
480
size_t i;
481
482
if (strsize)
483
*str = NUL; /* make sure we return a NUL terminated string. */
484
else
485
return str;
486
487
strused = 0;
488
for (i = 0; i < methodc; ++i)
489
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
490
method2string(methodv[i]));
491
492
return str;
493
}
494
495
int
496
string2method(methodname)
497
const char *methodname;
498
{
499
struct {
500
char *methodname;
501
int method;
502
} method[] = {
503
{ AUTHMETHOD_NONEs, AUTHMETHOD_NONE },
504
{ AUTHMETHOD_UNAMEs, AUTHMETHOD_UNAME },
505
{ AUTHMETHOD_RFC931s, AUTHMETHOD_RFC931 },
506
{ AUTHMETHOD_PAMs, AUTHMETHOD_PAM }
507
};
508
size_t i;
509
510
for (i = 0; i < ELEMENTS(method); ++i)
511
if (strcmp(method[i].methodname, methodname) == 0)
512
return method[i].method;
513
514
return -1;
515
}
516
517
518
char *
519
sockshost2string(host, string, len)
520
const struct sockshost_t *host;
521
char *string;
522
size_t len;
523
{
524
525
if (string == NULL) { /* to ease debugging. */
526
static char hstring[MAXSOCKSHOSTSTRING];
527
528
string = hstring;
529
len = sizeof(hstring);
530
}
531
532
switch (host->atype) {
533
case SOCKS_ADDR_IPV4:
534
snprintfn(string, len, "%s.%d",
535
inet_ntoa(host->addr.ipv4), ntohs(host->port));
536
break;
537
538
case SOCKS_ADDR_IPV6:
539
snprintfn(string, len, "%s.%d",
540
"<IPv6 address not supported>", ntohs(host->port));
541
break;
542
543
case SOCKS_ADDR_DOMAIN: {
544
char *name;
545
546
snprintfn(string, len, "%s.%d",
547
strcheck(name = str2vis(host->addr.domain, strlen(host->addr.domain))),
548
ntohs(host->port));
549
free(name);
550
break;
551
}
552
553
default:
554
SERRX(host->atype);
555
}
556
557
return string;
558
}
559
560
561
char *
562
sockaddr2string(address, string, len)
563
const struct sockaddr *address;
564
char *string;
565
size_t len;
566
{
567
568
/* for debugging. */
569
if (string == NULL) {
570
static char addrstring[MAXSOCKADDRSTRING];
571
572
string = addrstring;
573
len = sizeof(addrstring);
574
}
575
576
switch (address->sa_family) {
577
case AF_UNIX: {
578
/* LINTED pointer casts may be troublesome */
579
const struct sockaddr_un *addr = (const struct sockaddr_un *)address;
580
581
strncpy(string, addr->sun_path, len - 1);
582
string[len - 1] = NUL;
583
break;
584
}
585
586
case AF_INET: {
587
/* LINTED pointer casts may be troublesome */
588
const struct sockaddr_in *addr = TOCIN(address);
589
590
snprintfn(string, len, "%s.%d",
591
inet_ntoa(addr->sin_addr), ntohs(addr->sin_port));
592
break;
593
}
594
595
default:
596
SERRX(address->sa_family);
597
}
598
599
return string;
600
}
601
602
struct udpheader_t *
603
string2udpheader(data, len, header)
604
const char *data;
605
size_t len;
606
struct udpheader_t *header;
607
{
608
609
bzero(header, sizeof(*header));
610
611
if (len < sizeof(header->flag))
612
return NULL;
613
memcpy(&header->flag, data, sizeof(header->flag));
614
data += sizeof(header->flag);
615
len -= sizeof(header->flag);
616
617
if (len < sizeof(header->frag))
618
return NULL;
619
memcpy(&header->frag, data, sizeof(header->frag));
620
data += sizeof(header->frag);
621
len -= sizeof(header->frag);
622
623
if ((data = (const char *)mem2sockshost(&header->host,
624
(const unsigned char *)data, len, SOCKS_V5)) == NULL)
625
return NULL;
626
627
return header;
628
}
629
630
char *
631
extensions2string(extensions, str, strsize)
632
const struct extension_t *extensions;
633
char *str;
634
size_t strsize;
635
{
636
size_t strused;
637
638
if (strsize)
639
*str = NUL; /* make sure we return a NUL terminated string. */
640
else
641
return str;
642
643
strused = 0;
644
645
if (extensions->bind)
646
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
647
QUOTE("bind"));
648
649
return str;
650
}
651
652
653
#if SOCKS_SERVER
654
655
char *
656
logtypes2string(logtypes, str, strsize)
657
const struct logtype_t *logtypes;
658
char *str;
659
size_t strsize;
660
{
661
size_t strused;
662
size_t i;
663
664
if (strsize)
665
*str = NUL; /* make sure we return a NUL terminated string. */
666
else
667
return str;
668
669
strused = 0;
670
671
if (logtypes->type & LOGTYPE_SYSLOG)
672
strused += snprintfn(&str[strused], strsize - strused, "\"syslog.%s\", ",
673
logtypes->facilityname);
674
675
if (logtypes->type & LOGTYPE_FILE)
676
for (i = 0; i < logtypes->fpc; ++i)
677
strused += snprintfn(&str[strused], strsize - strused, "\"%s\", ",
678
logtypes->fnamev[i]);
679
680
return str;
681
}
682
683
char *
684
options2string(options, prefix, str, strsize)
685
const struct option_t *options;
686
const char *prefix;
687
char *str;
688
size_t strsize;
689
{
690
size_t strused;
691
692
if (strsize)
693
*str = NUL; /* make sure we return a NUL terminated string. */
694
else
695
return str;
696
697
strused = 0;
698
699
strused += snprintfn(&str[strused], strsize - strused,
700
"\"%sconfigfile\": \"%s\",\n", prefix, options->configfile == NULL ?
701
SOCKD_CONFIGFILE : options->configfile);
702
703
strused += snprintfn(&str[strused], strsize - strused,
704
"\"%sdaemon\": \"%d\",\n", prefix, options->daemon);
705
706
strused += snprintfn(&str[strused], strsize - strused,
707
"\"%sdebug\": \"%d\",\n", prefix, options->debug);
708
709
strused += snprintfn(&str[strused], strsize - strused,
710
"\"%skeepalive\": \"%d\",\n", prefix, options->keepalive);
711
712
strused += snprintfn(&str[strused], strsize - strused,
713
"\"%slinebuffer\": \"%d\",\n", prefix, options->debug);
714
715
strused += snprintfn(&str[strused], strsize - strused,
716
"\"%sservercount\": \"%d\",\n", prefix, options->serverc);
717
718
return str;
719
}
720
721
722
char *
723
logs2string(logs, str, strsize)
724
const struct log_t *logs;
725
char *str;
726
size_t strsize;
727
{
728
size_t strused;
729
730
if (strsize)
731
*str = NUL; /* make sure we return a NUL terminated string. */
732
else
733
return str;
734
735
strused = 0;
736
737
if (logs->connect)
738
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
739
QUOTE(LOG_CONNECTs));
740
741
if (logs->disconnect)
742
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
743
QUOTE(LOG_DISCONNECTs));
744
745
if (logs->data)
746
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
747
QUOTE(LOG_DATAs));
748
749
if (logs->error)
750
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
751
QUOTE(LOG_ERRORs));
752
753
if (logs->iooperation)
754
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
755
QUOTE(LOG_IOOPERATIONs));
756
757
return str;
758
}
759
760
const char *
761
childtype2string(type)
762
int type;
763
{
764
765
switch (type) {
766
case CHILD_IO:
767
return "io";
768
769
case CHILD_MOTHER:
770
return "mother";
771
772
case CHILD_NEGOTIATE:
773
return "negotiator";
774
775
case CHILD_REQUEST:
776
return "request";
777
778
default:
779
SERRX(type);
780
}
781
782
/* NOTREACHED */
783
}
784
785
const char *
786
verdict2string(verdict)
787
int verdict;
788
{
789
790
return verdict == VERDICT_PASS ?
791
QUOTE(VERDICT_PASSs) : QUOTE(VERDICT_BLOCKs);
792
}
793
794
char *
795
users2string(user, str, strsize)
796
const struct linkedname_t *user;
797
char *str;
798
size_t strsize;
799
{
800
size_t strused;
801
802
if (strsize)
803
*str = NUL; /* make sure we return a NUL terminated string. */
804
else
805
return str;
806
807
strused = 0;
808
809
for (; user != NULL; user = user->next)
810
strused += snprintfn(&str[strused], strsize - strused, "\"%s\", ",
811
user->name);
812
813
return str;
814
}
815
816
char *
817
compats2string(compats, str, strsize)
818
const struct compat_t *compats;
819
char *str;
820
size_t strsize;
821
{
822
size_t strused;
823
824
if (strsize)
825
*str = NUL; /* make sure we return a NUL terminated string. */
826
else
827
return str;
828
829
strused = 0;
830
831
if (compats->reuseaddr)
832
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
833
QUOTE("reuseaddr"));
834
835
if (compats->sameport)
836
strused += snprintfn(&str[strused], strsize - strused, "%s, ",
837
QUOTE("sameport"));
838
839
return str;
840
}
841
842
char *
843
srchosts2string(srchost, prefix, str, strsize)
844
const struct srchost_t *srchost;
845
const char *prefix;
846
char *str;
847
size_t strsize;
848
{
849
size_t strused;
850
851
if (strsize)
852
*str = NUL; /* make sure we return a NUL terminated string. */
853
else
854
return str;
855
856
strused = 0;
857
858
strused += snprintfn(&str[strused], strsize - strused,
859
"\"%snomismatch\": \"%d\",\n", prefix, srchost->nomismatch);
860
861
strused += snprintfn(&str[strused], strsize - strused,
862
"\"%snounknown\": \"%d\",\n", prefix, srchost->nounknown);
863
864
return str;
865
}
866
867
const char *
868
uid2name(uid)
869
uid_t uid;
870
{
871
struct passwd *pw;
872
873
if ((pw = getpwuid(uid)) == NULL)
874
return NULL;
875
876
return pw->pw_name;
877
}
878
879
char *
880
userids2string(userids, prefix, str, strsize)
881
const struct userid_t *userids;
882
const char *prefix;
883
char *str;
884
size_t strsize;
885
{
886
size_t strused;
887
888
if (strsize)
889
*str = NUL; /* make sure we return a NUL terminated string. */
890
else
891
return str;
892
893
strused = 0;
894
895
strused += snprintfn(&str[strused], strsize - strused,
896
"\"%sprivileged\": \"%s\",\n", prefix, uid2name(userids->privileged));
897
898
strused += snprintfn(&str[strused], strsize - strused,
899
"\"%sunprivileged\": \"%s\",\n", prefix, uid2name(userids->unprivileged));
900
901
strused += snprintfn(&str[strused], strsize - strused,
902
"\"%slibwrap\": \"%s\",\n", prefix, uid2name(userids->libwrap));
903
904
return str;
905
}
906
907
char *
908
timeouts2string(timeouts, prefix, str, strsize)
909
const struct timeout_t *timeouts;
910
const char *prefix;
911
char *str;
912
size_t strsize;
913
{
914
size_t strused;
915
916
if (strsize)
917
*str = NUL; /* make sure we return a NUL terminated string. */
918
else
919
return str;
920
921
strused = 0;
922
923
strused += snprintfn(&str[strused], strsize - strused,
924
"\"%snegotiate\": \"%ld\",\n", prefix, (long)timeouts->negotiate);
925
926
strused += snprintfn(&str[strused], strsize - strused,
927
"\"%sio\": \"%ld\",\n", prefix, (long)timeouts->io);
928
929
return str;
930
}
931
932
const char *
933
rotation2string(rotation)
934
int rotation;
935
{
936
937
switch (rotation) {
938
case ROTATION_NONE:
939
return "none";
940
941
case ROTATION_ROUTE:
942
return "route";
943
944
default:
945
SERRX(rotation);
946
}
947
948
/* NOTREACHED */
949
}
950
951
#endif /* SOCKS_SERVER */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1