« back to all changes in this revision
Viewing changes to dlib/msproxy_clientprotocol.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/msproxy_clientprotocol.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
/*
45
* This code is terrible so hopefully it will match the protocol.
46
*/
47
48
#include "common.h"
49
50
static const char rcsid[] =
51
"$Id: msproxy_clientprotocol.c,v 1.30 2003/07/01 13:21:30 michaels Exp $";
52
53
static char executable[] = "TELNET.EXE";
54
static struct sigaction oldsigio;
55
56
__BEGIN_DECLS
57
58
static int
59
msproxy_connect __P((int s, int control, struct socks_t *packet));
60
61
static int
62
msproxy_bind __P((int s, int control, struct socks_t *packet));
63
64
static char *
65
mem2response __P((struct msproxy_response_t *res, char *mem, size_t len));
66
67
static char *
68
request2mem __P((const struct msproxy_request_t *req, char *mem));
69
70
static void
71
msproxy_sessionsend __P((void));
72
/*
73
* Terminates all msproxy sessions.
74
*/
75
76
static void
77
msproxy_sessionend __P((int s, struct msproxy_state_t *msproxy));
78
/*
79
* ends the session negotiated with "s" and having state "msproxy".
80
*/
81
82
static void
83
msproxy_keepalive __P((int signal));
84
/*
85
* Sends a keepalive packet on behalf of all established sessions.
86
*/
87
88
static void
89
sigio __P((int sig));
90
91
__END_DECLS
92
93
int
94
msproxy_init(void)
95
{
96
const char *function = "msproxy_init()";
97
struct itimerval timerval;
98
struct sigaction sigact, oldsigact;
99
100
if (atexit(msproxy_sessionsend) != 0) {
101
swarn("%s: atexit()", function);
102
return -1;
103
}
104
105
if (sigaction(SIGALRM, NULL, &oldsigact) != 0) {
106
swarn("%s: sigaction(SIGALRM)", function);
107
return -1;
108
}
109
110
/* XXX */
111
if (oldsigact.sa_handler != SIG_DFL
112
&& oldsigact.sa_handler != SIG_IGN) {
113
swarnx("%s: could not install signalhandler for SIGALRM, already set",
114
function);
115
return 0; /* will probably timeout, don't consider it fatal for now. */
116
}
117
118
sigemptyset(&sigact.sa_mask);
119
sigact.sa_flags = SA_RESTART;
120
sigact.sa_handler = msproxy_keepalive;
121
if (sigaction(SIGALRM, &sigact, NULL) != 0) {
122
swarn("%s: sigaction(SIGALRM)", function);
123
return -1;
124
}
125
126
timerval.it_value.tv_sec = MSPROXY_PINGINTERVAL;
127
timerval.it_value.tv_usec = 0;
128
timerval.it_interval = timerval.it_value;
129
130
if (setitimer(ITIMER_REAL, &timerval, NULL) != 0) {
131
swarn("%s: setitimer()", function);
132
return -1;
133
}
134
135
srand((unsigned int)time(NULL) * getpid());
136
137
return 0;
138
}
139
140
int
141
msproxy_negotiate(s, control, packet)
142
int s;
143
int control;
144
struct socks_t *packet;
145
{
146
const char *function = "msproxy_negotiate()";
147
char string[MAXSOCKADDRSTRING];
148
struct msproxy_request_t req;
149
struct msproxy_response_t res;
150
int p;
151
152
slog(LOG_DEBUG, "%s: packet #1", function);
153
154
bzero(&req, sizeof(req));
155
req.clientid = htonl(0x0a000000);
156
req.command = htons(MSPROXY_HELLO);
157
158
/* in case we don't get something more sensible. */
159
packet->res.version = packet->req.version;
160
packet->res.reply = MSPROXY_FAILURE;
161
162
switch (packet->req.command) {
163
case SOCKS_BIND:
164
#if 1
165
req.packet._1.magic5 = htons(0x4800);
166
req.packet._1.magic10 = htons(0x1400);
167
req.packet._1.magic15 = htons(0x0400);
168
req.packet._1.magic20 = htons(0x5704);
169
req.packet._1.magic25 = htons(0x0004);
170
req.packet._1.magic30 = htons(0x0100);
171
req.packet._1.magic35 = htons(0x4a02);
172
req.packet._1.magic40 = htons(0x3000);
173
req.packet._1.magic45 = htons(0x4100);
174
req.packet._1.magic50 = htons(0x3900);
175
#endif
176
break;
177
178
case SOCKS_CONNECT:
179
#if 0
180
req.packet._1.magic5 = htons(0x4b00);
181
req.packet._1.magic10 = htons(0x1400);
182
req.packet._1.magic15 = htons(0x0400);
183
req.packet._1.magic20 = htons(0x5704);
184
req.packet._1.magic25 = htons(0x0004);
185
req.packet._1.magic30 = htons(0x0100);
186
req.packet._1.magic35 = htons(0x4a02);
187
req.packet._1.magic40 = htons(0x3000);
188
req.packet._1.magic45 = htons(0x4400);
189
req.packet._1.magic50 = htons(0x3900);
190
#endif
191
break;
192
193
case SOCKS_UDPASSOCIATE:
194
SERRX(packet->req.command);
195
/* NOTREACHED */
196
197
default:
198
SERRX(packet->req.command);
199
}
200
201
if (socks_getusername(&packet->gw.host, req.username, sizeof(req.username))
202
== NULL)
203
return -1;
204
205
*req.unknown = NUL;
206
207
strncpy(req.executable, executable, sizeof(req.executable) - 1);
208
req.executable[sizeof(req.executable) - 1] = NUL;
209
210
*req.clienthost = NUL;
211
212
#if 0
213
strncpy(req.clienthost, "foo", sizeof(req.clienthost) - 1);
214
req.clienthost[sizeof(req.clienthost) - 1] = NUL;
215
#endif
216
217
if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
218
return -1;
219
220
if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
221
return -1;
222
223
if (strcmp(res.RWSP, "RWSP") != 0)
224
serrx(EXIT_FAILURE, "expected \"RWSP\", got \"%s\"",
225
str2vis(res.RWSP, sizeof(res.RWSP)));
226
227
if (ntohs(res.command) >> 8 != 0x10)
228
serrx(EXIT_FAILURE, "expected res.command = 10??, is %x",
229
ntohs(res.command));
230
231
packet->state.msproxy.controladdr.sin_family = AF_INET;
232
packet->state.msproxy.controladdr.sin_port = res.packet._1.udpport;
233
packet->state.msproxy.controladdr.sin_addr.s_addr = res.packet._1.udpaddr;
234
235
packet->state.msproxy.clientid = htonl(rand());
236
packet->state.msproxy.serverid = res.serverid;
237
238
slog(LOG_DEBUG, "%s: clientid: 0x%x, serverid: 0x%0x",
239
function, packet->state.msproxy.clientid, packet->state.msproxy.serverid);
240
241
/* LINTED pointer casts may be troublesome */
242
slog(LOG_DEBUG, "%s: msproxy controladdress: %s",
243
function,
244
sockaddr2string((struct sockaddr *)&packet->state.msproxy.controladdr,
245
string, sizeof(string)));
246
247
248
slog(LOG_DEBUG, "%s: packet #2", function);
249
250
/* almost identical. */
251
req.clientid = packet->state.msproxy.clientid;
252
req.serverid = packet->state.msproxy.serverid;
253
254
if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
255
return -1;
256
257
if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
258
return -1;
259
260
if (res.serverid != packet->state.msproxy.serverid)
261
serrx(EXIT_FAILURE, "expected serverid = 0x%x, is 0x%x",
262
packet->state.msproxy.serverid, res.serverid);
263
264
if (res.sequence != 0x01)
265
serrx(EXIT_FAILURE, "expected res.sequence = 0x%x, is 0x%x",
266
0x01, res.sequence);
267
268
if (ntohs(res.command) != MSPROXY_USERINFO_ACK)
269
serrx(EXIT_FAILURE, "expected res.command = 0x%x, is 0x%x",
270
MSPROXY_USERINFO_ACK, ntohs(res.command));
271
272
switch (packet->req.command) {
273
case SOCKS_BIND:
274
p = msproxy_bind(s, control, packet);
275
break;
276
277
case SOCKS_CONNECT:
278
p = msproxy_connect(s, control, packet);
279
break;
280
281
case SOCKS_UDPASSOCIATE:
282
default:
283
SERRX(packet->req.command);
284
}
285
286
return p;
287
}
288
289
static int
290
msproxy_connect(s, control, packet)
291
int s;
292
int control;
293
struct socks_t *packet;
294
{
295
const char *function = "msproxy_connect()";
296
char string[MAXSOCKSHOSTSTRING];
297
struct msproxy_request_t req;
298
struct msproxy_response_t res;
299
struct sockaddr_in addr;
300
socklen_t len;
301
302
slog(LOG_DEBUG, function);
303
304
#if 0
305
306
bzero(&req, sizeof(req));
307
req.clientid = packet->state.msproxy.clientid;
308
req.serverid = packet->state.msproxy.serverid;
309
req.command = htons(MSPROXY_SOMETHING);
310
memcpy(req.packet._3.NTLMSSP, "NTLMSSP", sizeof("NTLMSSP"));
311
req.packet._3.bindaddr = htonl(0x02000000);
312
req.packet._3.magic5 = htons(0x0100);
313
req.packet._3.magic10 = htons(0x9682);
314
#if 0
315
req.packet._3.magic50 = htons(0x3000);
316
req.packet._3.magic55 = htons(0x3000);
317
#endif
318
319
if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
320
return -1;
321
322
if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
323
return -1;
324
325
if (res.serverid != packet->state.msproxy.serverid)
326
serrx(EXIT_FAILURE, "expected serverid = 0x%x, is 0x%x",
327
packet->state.msproxy.serverid, res.serverid);
328
329
if (ntohs(res.command) != MSPROXY_SOMETHING_1_ACK)
330
serrx(EXIT_FAILURE, "expected res.command = 0x%x, is 0x%x",
331
MSPROXY_SOMETHING_1_ACK, ntohs(res.command));
332
333
slog(LOG_DEBUG, "%s: ntdomain: \"%s\"", function, res.packet._3.ntdomain);
334
335
336
slog(LOG_DEBUG, "%s: packet #4", function);
337
338
bzero(&req, sizeof(req));
339
req.clientid = packet->state.msproxy.clientid;
340
req.serverid = packet->state.msproxy.serverid;
341
req.command = htons(MSPROXY_SOMETHING_2);
342
#if 0
343
memcpy(req.packet._4.NTLMSSP, "NTLMSSP", sizeof("NTLMSSP"));
344
req.packet._4.magic3 = htons(0x0200);
345
req.packet._4.magic5 = htons(0x0300);
346
req.packet._4.magic10 = htons(0x1800);
347
req.packet._4.magic15 = htons(0x1800);
348
req.packet._4.magic20 = htons(0x4900);
349
req.packet._4.magic30 = htons(0x6100);
350
req.packet._4.magic35 = htons(0x0800);
351
req.packet._4.magic40 = htons(0x0800);
352
req.packet._4.magic45 = htons(0x3400);
353
req.packet._4.magic50 = htons(0x0700);
354
req.packet._4.magic55 = htons(0x0700);
355
req.packet._4.magic60 = htons(0x3c00);
356
req.packet._4.magic65 = htons(0x0600);
357
req.packet._4.magic70 = htons(0x0600);
358
req.packet._4.magic75 = htons(0x4300);
359
#endif
360
361
if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
362
return -1;
363
364
if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
365
return -1;
366
367
if (res.serverid != packet->state.msproxy.serverid)
368
serrx(EXIT_FAILURE, "expected res.serverid = 0x%x, is 0x%x",
369
packet->state.msproxy.serverid, res.serverid);
370
371
if (res.clientack != 0x01)
372
serrx(EXIT_FAILURE, "expected res.clientack = 0x%x, is 0x%x",
373
0x01, res.clientack);
374
375
if (ntohs(res.command) >> 8 != 0x47)
376
serrx(EXIT_FAILURE, "expected res.command = 47??, is 0x%x",
377
ntohs(res.command));
378
#endif
379
380
switch (packet->req.host.atype) {
381
case SOCKS_ADDR_IPV4:
382
/* LINTED pointer casts may be troublesome */
383
sockshost2sockaddr(&packet->req.host, (struct sockaddr *)&addr);
384
break;
385
386
case SOCKS_ADDR_DOMAIN:
387
slog(LOG_DEBUG, "%s: resolve packet", function);
388
389
bzero(&req, sizeof(req));
390
req.clientid = packet->state.msproxy.clientid;
391
req.serverid = packet->state.msproxy.serverid;
392
393
req.command = htons(MSPROXY_RESOLVE);
394
req.packet.resolve.hostlength
395
= (unsigned char)(strlen(packet->req.host.addr.domain) + 1);
396
memcpy(&req.packet.resolve.host, packet->req.host.addr.domain,
397
(size_t)req.packet.resolve.hostlength);
398
399
if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
400
return -1;
401
402
if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
403
return -1;
404
405
if (ntohs(res.command) != MSPROXY_RESOLVE_ACK)
406
serrx(EXIT_FAILURE, "expected res.command = 0x%x, is 0x%x",
407
MSPROXY_RESOLVE_ACK, ntohs(res.command));
408
409
addr.sin_addr.s_addr = res.packet.resolve.hostaddr;
410
slog(LOG_DEBUG, "%s: IP address of %s: %s",
411
function, packet->req.host.addr.domain, inet_ntoa(addr.sin_addr));
412
413
break;
414
415
default:
416
SERRX(packet->req.host.atype);
417
}
418
419
420
slog(LOG_DEBUG, "%s: packet #5", function);
421
422
bzero(&req, sizeof(req));
423
req.clientid = packet->state.msproxy.clientid;
424
req.serverid = packet->state.msproxy.serverid;
425
req.command = htons(MSPROXY_CONNECT);
426
req.packet._5.magic6 = htons(0x0200);
427
req.packet._5.destport = packet->req.host.port;
428
req.packet._5.destaddr = addr.sin_addr.s_addr;
429
430
/*
431
* need to tell server what port we will connect from, so if socket
432
* is not bound, bind it.
433
*/
434
435
len = sizeof(addr);
436
/* LINTED pointer casts may be troublesome */
437
if (getsockname(s, (struct sockaddr *)&addr, &len) != 0)
438
return -1;
439
440
if (!ADDRISBOUND(addr)) {
441
/*
442
* Don't have any specific preference for what address to bind and
443
* proxyserver only expects to be told port.
444
*/
445
446
addr.sin_addr.s_addr = htonl(INADDR_ANY);
447
/* LINTED pointer casts may be troublesome */
448
if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) != 0)
449
return -1;
450
451
len = sizeof(addr);
452
/* LINTED pointer casts may be troublesome */
453
if (getsockname(s, (struct sockaddr *)&addr, &len) != 0)
454
return -1;
455
}
456
req.packet._5.srcport = addr.sin_port;
457
458
if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
459
return -1;
460
461
if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
462
return -1;
463
464
if (ntohs(res.command) != MSPROXY_CONNECT_ACK) {
465
swarnx("expected res.command = 0x%x, is 0x%x",
466
MSPROXY_CONNECT_ACK, ntohs(res.command));
467
packet->res.reply = MSPROXY_NOTALLOWED;
468
return -1;
469
}
470
471
packet->res.host.atype = SOCKS_ADDR_IPV4;
472
packet->res.host.port = res.packet._5.clientport;
473
packet->res.host.addr.ipv4.s_addr = res.packet._5.clientaddr;
474
475
if (socks_connect(s, &packet->res.host) != 0) {
476
swarn("%s: failed to connect to %s",
477
function, sockshost2string(&packet->res.host, string, sizeof(string)));
478
return -1;
479
}
480
else
481
slog(LOG_DEBUG, "%s: connected to %s",
482
function, sockshost2string(&packet->res.host, string, sizeof(string)));
483
484
packet->res.host.atype = SOCKS_ADDR_IPV4;
485
packet->res.host.port = res.packet._5.clientport;
486
packet->res.host.addr.ipv4.s_addr = res.packet._5.clientaddr;
487
488
/* LINTED pointer casts may be troublesome */
489
slog(LOG_DEBUG, "%s: server will use as source address: %s",
490
function, sockshost2string(&packet->res.host, string, sizeof(string)));
491
492
493
slog(LOG_DEBUG, "%s: packet #6", function);
494
495
bzero(&req, sizeof(req));
496
req.clientid = packet->state.msproxy.clientid;
497
req.serverid = packet->state.msproxy.serverid;
498
req.command = htons(MSPROXY_CONNECTED);
499
500
if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
501
return -1;
502
503
504
/* make response look sensible. */
505
packet->res.version = packet->req.version;
506
packet->res.reply = MSPROXY_SUCCESS;
507
packet->res.flag = 0;
508
packet->res.auth = NULL;
509
510
return 0;
511
}
512
513
static int
514
msproxy_bind(s, control, packet)
515
int s;
516
int control;
517
struct socks_t *packet;
518
{
519
const char *function = "msproxy_bind()";
520
char string[MAXSOCKSHOSTSTRING];
521
struct msproxy_request_t req;
522
struct msproxy_response_t res;
523
struct sockaddr_in addr;
524
socklen_t len;
525
526
slog(LOG_DEBUG, function);
527
528
bzero(&req, sizeof(req));
529
req.clientid = packet->state.msproxy.clientid;
530
req.serverid = packet->state.msproxy.serverid;
531
req.command = htons(MSPROXY_BIND);
532
req.packet._3.magic2 = htons(0x0100);
533
req.packet._3.bindaddr = packet->req.host.addr.ipv4.s_addr;
534
req.packet._3.bindport = packet->req.host.port;
535
req.packet._3.magic3 = htons(0x0200);
536
len = sizeof(addr);
537
/* LINTED pointer casts may be troublesome */
538
if (getsockname(s, (struct sockaddr *)&addr, &len) != 0)
539
return -1;
540
req.packet._3.boundport = addr.sin_port;
541
542
if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
543
return -1;
544
545
if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
546
return -1;
547
548
if (res.serverid != packet->state.msproxy.serverid)
549
serrx(EXIT_FAILURE, "expected serverid = 0x%x, is 0x%x",
550
packet->state.msproxy.serverid, res.serverid);
551
552
if (ntohs(res.command) != MSPROXY_BIND_ACK) {
553
swarnx("expected res.command = 0x%x, is 0x%x",
554
MSPROXY_BIND_ACK, ntohs(res.command));
555
packet->res.reply = MSPROXY_NOTALLOWED;
556
return -1;
557
}
558
559
packet->state.msproxy.bindid = res.packet._3.magic10;
560
packet->res.host.atype = SOCKS_ADDR_IPV4;
561
packet->res.host.port = res.packet._3.boundport;
562
packet->res.host.addr.ipv4.s_addr = res.packet._3.boundaddr;
563
564
slog(LOG_DEBUG, "%s: server bound for us: %s",
565
function, sockshost2string(&packet->res.host, string, sizeof(string)));
566
567
slog(LOG_DEBUG, "%s: packet #4", function);
568
569
bzero(&req, sizeof(req));
570
req.clientid = packet->state.msproxy.clientid;
571
req.serverid = packet->state.msproxy.serverid;
572
req.command = htons(MSPROXY_BIND2);
573
req.packet._4.magic1 = htons(0x0100);
574
req.packet._4.magic2 = packet->state.msproxy.bindid;
575
req.packet._4.magic3 = htons(0x0500);
576
memcpy(req.packet._4.pad3 + 2, &addr.sin_port, sizeof(addr.sin_port));
577
req.packet._4.magic4 = htons(0x0200);
578
req.packet._4.boundport = addr.sin_port;
579
580
if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
581
return -1;
582
583
if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
584
return -1;
585
586
if (res.serverid != packet->state.msproxy.serverid)
587
serrx(EXIT_FAILURE, "expected res.serverid = 0x%x, is 0x%x",
588
packet->state.msproxy.serverid, res.serverid);
589
590
if (res.clientack != 0x01)
591
serrx(EXIT_FAILURE, "expected res.clientack = 0x%x, is 0x%x",
592
0x01, res.clientack);
593
594
if (ntohs(res.command) != MSPROXY_BIND2_ACK) {
595
swarnx("expected res.command = %x, is 0x%x",
596
MSPROXY_BIND2_ACK, ntohs(res.command));
597
return -1;
598
}
599
600
601
slog(LOG_DEBUG, "%s: packet #5", function);
602
603
bzero(&req, sizeof(req));
604
req.clientid = packet->state.msproxy.clientid;
605
req.serverid = packet->state.msproxy.serverid;
606
req.command = htons(MSPROXY_LISTEN);
607
req.packet._5.magic6 = htons(0x0200);
608
req.packet._5.destport = packet->res.host.port;
609
req.packet._5.destaddr = packet->res.host.addr.ipv4.s_addr;
610
611
if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
612
return -1;
613
614
/*
615
* When the server accepts the client, it will send us a new
616
* controlpacket. That will be caught in sigio().
617
*/
618
619
slog(LOG_DEBUG, "%s: waiting for forwarded connection...", function);
620
621
/* make response look sensible. */
622
packet->res.version = packet->req.version;
623
packet->res.reply = MSPROXY_SUCCESS;
624
packet->res.flag = 0;
625
packet->res.auth = NULL;
626
627
return 0;
628
}
629
630
int
631
msproxy_sigio(s)
632
int s;
633
{
634
const char *function = "msproxy_sigio()";
635
static int init;
636
const int errno_s = errno;
637
struct socksfd_t *socksfd;
638
int p;
639
640
/*
641
* The msproxy protocol sends a udp packet which we must ack
642
* before it will connect to us. We set up the controlsocket
643
* for signaldriven i/o so we can ack it asynchronously.
644
*
645
*/
646
647
SASSERTX(socks_addrisok((unsigned int)s));
648
socksfd = socks_getaddr((unsigned int)s);
649
SASSERTX(socksfd->state.version == MSPROXY_V2);
650
651
if (!init) { /* could be smarter about this... */
652
struct sigaction sigact;
653
654
sigemptyset(&sigact.sa_mask);
655
sigact.sa_flags = SA_RESTART;
656
sigact.sa_handler = sigio;
657
if (sigaction(SIGIO, &sigact, &oldsigio) != 0)
658
return -1;
659
660
init = 1;
661
}
662
663
if (fcntl(socksfd->control, F_SETOWN, getpid()) == -1)
664
return -1;
665
666
p = 1;
667
if (ioctl(socksfd->control, FIOASYNC, &p) == -1)
668
return -1;
669
670
slog(LOG_DEBUG, "%s: set up sigio for %d", function, socksfd->control);
671
672
errno = errno_s;
673
return 0;
674
}
675
676
/* ARGSUSED */
677
static void
678
sigio(sig)
679
int sig;
680
{
681
const char *function = "sigio()";
682
const int errno_s = errno;
683
char string[MAXSOCKSHOSTSTRING];
684
int i, max, dset;
685
struct socksfd_t *socksfd;
686
fd_set rset;
687
struct timeval timeout;
688
int dbits;
689
690
slog(LOG_DEBUG, function);
691
692
/*
693
* Find the socket we were signalled for.
694
*/
695
696
dbits = -1;
697
FD_ZERO(&rset);
698
699
for (i = 0, max = getdtablesize(); i < max; ++i) {
700
if ((socksfd = socks_getaddr((unsigned int)i)) == NULL)
701
continue;
702
703
if (socksfd->state.command != SOCKS_BIND
704
|| socksfd->state.version != MSPROXY_V2
705
|| !socksfd->state.inprogress)
706
continue;
707
708
if (!socks_addrisok((unsigned int)i))
709
continue;
710
711
SASSERTX(fdisopen(socksfd->control));
712
713
FD_SET(socksfd->control, &rset);
714
dbits = MAX(dbits, socksfd->control);
715
}
716
717
if (dbits == -1) {
718
if (oldsigio.sa_handler != NULL)
719
oldsigio.sa_handler(sig);
720
return; /* old signal handler. */
721
}
722
723
dset = 0;
724
do {
725
fd_set newrset;
726
timeout.tv_sec = 0;
727
timeout.tv_usec = 0;
728
729
newrset = rset;
730
switch (selectn(dbits + 1, &newrset, NULL, NULL, &timeout)) {
731
case -1:
732
SERR(-1);
733
/* NOTREACHED */
734
735
case 0:
736
dset = 0;
737
slog(LOG_DEBUG, "%s: no descriptors readable", function);
738
if (oldsigio.sa_handler != NULL)
739
oldsigio.sa_handler(sig);
740
break;
741
742
default: {
743
dset = 1;
744
for (i = 0, max = getdtablesize(); i < max; ++i) {
745
if ((socksfd = socks_getaddr((unsigned int)i)) == NULL)
746
continue;
747
748
if (FD_ISSET(socksfd->control, &newrset)) {
749
struct sockshost_t host;
750
struct msproxy_request_t req;
751
struct msproxy_response_t res;
752
int p;
753
754
SASSERTX(socksfd->state.command == SOCKS_BIND
755
&& socksfd->state.version == MSPROXY_V2
756
&& socksfd->state.inprogress);
757
758
slog(LOG_DEBUG, "%s: attempting to receive bind info...",
759
function);
760
761
FD_CLR(socksfd->control, &newrset);
762
763
if (recv_mspresponse(socksfd->control,
764
&socksfd->state.msproxy, &res) == -1)
765
continue;
766
767
if (ntohs(res.command) != MSPROXY_BINDINFO) {
768
swarnx("%s: expected res.command = %x, is 0x%x",
769
function, MSPROXY_BINDINFO, ntohs(res.command));
770
continue;
771
}
772
773
/* no need for more signals on this socket. */
774
p = 0;
775
if (ioctl(socksfd->control, FIOASYNC, &p) == -1) {
776
swarn("%s: ioctl(socksfd->control)", function);
777
continue;
778
}
779
780
slog(LOG_DEBUG, "%s: turned off sigio for %d",
781
function, socksfd->control);
782
783
/*
784
* if we asked server to bind INADDR_ANY, we don't know
785
* what address it bound until now.
786
*/
787
host.atype = SOCKS_ADDR_IPV4;
788
host.port = res.packet._5.boundport;
789
host.addr.ipv4.s_addr = res.packet._5.boundaddr;
790
sockshost2sockaddr(&host, &socksfd->remote);
791
792
slog(LOG_DEBUG, "%s: server bound address %s",
793
function, sockshost2string(&host, string, sizeof(string)));
794
795
host.atype = SOCKS_ADDR_IPV4;
796
host.port = res.packet._5.clientport;
797
host.addr.ipv4.s_addr = res.packet._5.clientaddr;
798
sockshost2sockaddr(&host, &socksfd->forus.accepted);
799
800
slog(LOG_DEBUG, "%s: server accepted: %s",
801
function, sockshost2string(&host, string, sizeof(string)));
802
803
slog(LOG_DEBUG, "%s: server will connect to us from port %d",
804
function, ntohs(res.packet._5.serverport));
805
806
/* LINTED pointer casts may be troublesome */
807
TOIN(&socksfd->reply)->sin_port = res.packet._5.serverport;
808
809
slog(LOG_DEBUG, "%s: packet #6", function);
810
811
bzero(&req, sizeof(req));
812
req.clientid = socksfd->state.msproxy.clientid;
813
req.serverid = socksfd->state.msproxy.serverid;
814
req.command = htons(MSPROXY_BINDINFO_ACK);
815
req.packet._6.magic1 = res.packet._5.magic1;
816
req.packet._6.magic5 = htons(0x0100);
817
req.packet._6.magic10 = socksfd->state.msproxy.bindid;
818
req.packet._6.magic15 = htons(0x0100);
819
req.packet._6.magic16 = socksfd->state.msproxy.bindid;
820
req.packet._6.magic20 = htons(0x0200);
821
req.packet._6.clientport = res.packet._5.clientport;
822
req.packet._6.clientaddr = res.packet._5.clientaddr;
823
req.packet._6.magic30 = res.packet._5.magic10;
824
req.packet._6.magic35 = res.packet._5.magic15;
825
req.packet._6.serverport = res.packet._5.serverport;
826
req.packet._6.srcport = res.packet._5.srcport;
827
req.packet._6.boundport = res.packet._5.boundport;
828
req.packet._6.boundaddr = res.packet._5.boundaddr;
829
830
if (send_msprequest(socksfd->control, &socksfd->state.msproxy,
831
&req) == -1)
832
continue;
833
834
if (recv_mspresponse(socksfd->control,
835
&socksfd->state.msproxy, &res) == -1)
836
continue;
837
838
/* all done. Can accept(). */
839
socksfd->state.inprogress = 0;
840
}
841
}
842
}
843
}
844
} while (dset != 0);
845
846
errno = errno_s;
847
}
848
849
850
int
851
recv_mspresponse(s, state, response)
852
int s;
853
struct msproxy_state_t *state;
854
struct msproxy_response_t *response;
855
{
856
const char *function = "recv_mspresponse()";
857
/* CONSTCOND */
858
char responsemem[MAX(sizeof(*response), 1024)];
859
ssize_t r;
860
861
/* CONSTCOND */
862
while (1) {
863
if ((r = read(s, responsemem, sizeof(responsemem))) < MSPROXY_MINLENGTH) {
864
swarn("%s: expected to read atleast %d, read %d",
865
function, MSPROXY_MINLENGTH, r);
866
return -1;
867
}
868
869
if (mem2response(response, responsemem, (size_t)r) == NULL) {
870
swarnx("%s: bad response from server", function);
871
return -1;
872
}
873
874
if (state->seq_recv > 0) {
875
if (response->sequence == state->seq_recv + 1)
876
break; /* all ok. */
877
else if (response->sequence < state->seq_recv) {
878
/*
879
* sequence number less that last, sometimes this happens too,
880
* don't know why.
881
*/
882
slog(LOG_DEBUG, "%s: sequence (%d) < seq_recv (%d)",
883
function, response->sequence, state->seq_recv);
884
break;
885
}
886
else if (response->sequence == state->seq_recv) {
887
slog(LOG_DEBUG, "%s: seq_recv: %d, dup response, seqnumber: 0x%x",
888
function, state->seq_recv, response->sequence);
889
890
if (response->clientack == state->seq_sent) {
891
slog(LOG_DEBUG,
892
"%s: ack matches last sent though, hoping it's a new one...",
893
function);
894
break;
895
}
896
}
897
else if (response->sequence > state->seq_recv) {
898
slog(LOG_DEBUG, "%s: sequence (%d) > seq_recv (%d)",
899
function, response->sequence, state->seq_recv);
900
break;
901
}
902
}
903
else
904
break; /* not started incrementing yet. */
905
}
906
907
state->seq_recv = response->sequence;
908
909
return r;
910
}
911
912
913
int
914
send_msprequest(s, state, request)
915
int s;
916
struct msproxy_state_t *state;
917
struct msproxy_request_t *request;
918
{
919
const char *function = "send_msprequest()";
920
ssize_t w;
921
char requestmem[sizeof(struct msproxy_request_t)], *p;
922
923
request->magic25 = htonl(MSPROXY_VERSION);
924
request->serverack = state->seq_recv;
925
/* don't start incrementing sequence until we are acking packet #2. */
926
request->sequence
927
= (unsigned char)(request->serverack >= 2 ? state->seq_sent + 1 : 0);
928
929
memcpy(request->RWSP, "RWSP", sizeof(request->RWSP));
930
931
p = request2mem(request, requestmem);
932
933
/* all requests must be atleast MSPROXY_MINLENGTH it seems. */
934
if (p - requestmem < MSPROXY_MINLENGTH) {
935
bzero(p, (size_t)(MSPROXY_MINLENGTH - (p - requestmem)));
936
p = requestmem + MSPROXY_MINLENGTH;
937
}
938
939
if ((w = write(s, requestmem, (size_t)(p - requestmem)))
940
!= (ssize_t)(p - requestmem)) {
941
swarn("%s: write()", function);
942
return -1;
943
}
944
state->seq_sent = request->sequence;
945
946
return w;
947
}
948
949
static char *
950
mem2response(res, mem, len)
951
struct msproxy_response_t *res;
952
char *mem;
953
size_t len;
954
{
955
const char *function = "mem2response()";
956
957
if (len < sizeof(res->packetid))
958
return NULL;
959
memcpy(&res->packetid, mem, sizeof(res->packetid));
960
mem += sizeof(res->packetid);
961
len -= sizeof(res->packetid);
962
963
if (len < sizeof(res->magic5))
964
return NULL;
965
memcpy(&res->magic5, mem, sizeof(res->magic5));
966
mem += sizeof(res->magic5);
967
len -= sizeof(res->magic5);
968
969
if (len < sizeof(res->serverid))
970
return NULL;
971
memcpy(&res->serverid, mem, sizeof(res->serverid));
972
mem += sizeof(res->serverid);
973
len -= sizeof(res->serverid);
974
975
if (len < sizeof(res->clientack))
976
return NULL;
977
memcpy(&res->clientack, mem, sizeof(res->clientack));
978
mem += sizeof(res->clientack);
979
len -= sizeof(res->clientack);
980
981
if (len < sizeof(res->pad5))
982
return NULL;
983
memcpy(res->pad5, mem, sizeof(res->pad5));
984
mem += sizeof(res->pad5);
985
len -= sizeof(res->pad5);
986
987
if (len < sizeof(res->sequence))
988
return NULL;
989
memcpy(&res->sequence, mem, sizeof(res->sequence));
990
mem += sizeof(res->sequence);
991
len -= sizeof(res->sequence);
992
993
if (len < sizeof(res->pad10))
994
return NULL;
995
memcpy(res->pad10, mem, sizeof(res->pad10));
996
mem += sizeof(res->pad10);
997
len -= sizeof(res->pad10);
998
999
if (len < sizeof(res->RWSP))
1000
return NULL;
1001
memcpy(res->RWSP, mem, sizeof(res->RWSP));
1002
mem += sizeof(res->RWSP);
1003
len -= sizeof(res->RWSP);
1004
1005
if (len < sizeof(res->pad15))
1006
return NULL;
1007
memcpy(res->pad15, mem, sizeof(res->pad15));
1008
mem += sizeof(res->pad15);
1009
len -= sizeof(res->pad15);
1010
1011
if (len < sizeof(res->command))
1012
return NULL;
1013
memcpy(&res->command, mem, sizeof(res->command));
1014
mem += sizeof(res->command);
1015
len -= sizeof(res->command);
1016
1017
switch (ntohs(res->command)) {
1018
case MSPROXY_HELLO_ACK:
1019
if (len < sizeof(res->packet._1.pad5))
1020
return NULL;
1021
memcpy(res->packet._1.pad5, mem, sizeof(res->packet._1.pad5));
1022
mem += sizeof(res->packet._1.pad5);
1023
len -= sizeof(res->packet._1.pad5);
1024
1025
if (len < sizeof(res->packet._1.magic20))
1026
return NULL;
1027
memcpy(&res->packet._1.magic20, mem, sizeof(res->packet._1.magic20));
1028
mem += sizeof(res->packet._1.magic20);
1029
len -= sizeof(res->packet._1.magic20);
1030
1031
if (len < sizeof(res->packet._1.pad10))
1032
return NULL;
1033
memcpy(&res->packet._1.pad10, mem, sizeof(res->packet._1.pad10));
1034
mem += sizeof(res->packet._1.pad10);
1035
len -= sizeof(res->packet._1.pad10);
1036
1037
if (len < sizeof(res->packet._1.magic30))
1038
return NULL;
1039
memcpy(&res->packet._1.magic30, mem, sizeof(res->packet._1.magic30));
1040
mem += sizeof(res->packet._1.magic30);
1041
len -= sizeof(res->packet._1.magic30);
1042
1043
if (len < sizeof(res->packet._1.pad15))
1044
return NULL;
1045
memcpy(res->packet._1.pad15, mem, sizeof(res->packet._1.pad15));
1046
mem += sizeof(res->packet._1.pad15);
1047
len -= sizeof(res->packet._1.pad15);
1048
1049
if (len < sizeof(res->packet._1.magic35))
1050
return NULL;
1051
memcpy(&res->packet._1.magic35, mem, sizeof(res->packet._1.magic35));
1052
mem += sizeof(res->packet._1.magic35);
1053
len -= sizeof(res->packet._1.magic35);
1054
1055
if (len < sizeof(res->packet._1.pad20))
1056
return NULL;
1057
memcpy(res->packet._1.pad20, mem, sizeof(res->packet._1.pad20));
1058
mem += sizeof(res->packet._1.pad20);
1059
len -= sizeof(res->packet._1.pad20);
1060
1061
if (len < sizeof(res->packet._1.magic50))
1062
return NULL;
1063
memcpy(&res->packet._1.magic50, mem, sizeof(res->packet._1.magic50));
1064
mem += sizeof(res->packet._1.magic50);
1065
len -= sizeof(res->packet._1.magic50);
1066
1067
if (len < sizeof(res->packet._1.pad30))
1068
return NULL;
1069
memcpy(res->packet._1.pad30, mem, sizeof(res->packet._1.pad30));
1070
mem += sizeof(res->packet._1.pad30);
1071
len -= sizeof(res->packet._1.pad30);
1072
1073
if (len < sizeof(res->packet._1.magic60))
1074
return NULL;
1075
memcpy(&res->packet._1.magic60, mem, sizeof(res->packet._1.magic60));
1076
mem += sizeof(res->packet._1.magic60);
1077
len -= sizeof(res->packet._1.magic60);
1078
1079
if (len < sizeof(res->packet._1.pad35))
1080
return NULL;
1081
memcpy(res->packet._1.pad35, mem, sizeof(res->packet._1.pad35));
1082
mem += sizeof(res->packet._1.pad35);
1083
len -= sizeof(res->packet._1.pad35);
1084
1085
if (len < sizeof(res->packet._1.magic65))
1086
return NULL;
1087
memcpy(&res->packet._1.magic65, mem, sizeof(res->packet._1.magic65));
1088
mem += sizeof(res->packet._1.magic65);
1089
len -= sizeof(res->packet._1.magic65);
1090
1091
if (len < sizeof(res->packet._1.pad40))
1092
return NULL;
1093
memcpy(res->packet._1.pad40, mem, sizeof(res->packet._1.pad40));
1094
mem += sizeof(res->packet._1.pad40);
1095
len -= sizeof(res->packet._1.pad40);
1096
1097
if (len < sizeof(res->packet._1.udpport))
1098
return NULL;
1099
memcpy(&res->packet._1.udpport, mem, sizeof(res->packet._1.udpport));
1100
mem += sizeof(res->packet._1.udpport);
1101
len -= sizeof(res->packet._1.udpport);
1102
1103
if (len < sizeof(res->packet._1.udpaddr))
1104
return NULL;
1105
memcpy(&res->packet._1.udpaddr, mem, sizeof(res->packet._1.udpaddr));
1106
mem += sizeof(res->packet._1.udpaddr);
1107
len -= sizeof(res->packet._1.udpaddr);
1108
1109
break;
1110
1111
case MSPROXY_USERINFO_ACK:
1112
if (len < sizeof(res->packet._2.pad5))
1113
return NULL;
1114
memcpy(res->packet._2.pad5, mem, sizeof(res->packet._2.pad5));
1115
mem += sizeof(res->packet._2.pad5);
1116
len -= sizeof(res->packet._2.pad5);
1117
1118
if (len < sizeof(res->packet._2.magic5))
1119
return NULL;
1120
memcpy(&res->packet._2.magic5, mem, sizeof(res->packet._2.magic5));
1121
mem += sizeof(res->packet._2.magic5);
1122
len -= sizeof(res->packet._2.magic5);
1123
1124
break;
1125
1126
case MSPROXY_BIND_ACK:
1127
case MSPROXY_SOMETHING_1_ACK:
1128
if (len < sizeof(res->packet._3.pad1))
1129
return NULL;
1130
memcpy(res->packet._3.pad1, mem, sizeof(res->packet._3.pad1));
1131
mem += sizeof(res->packet._3.pad1);
1132
len -= sizeof(res->packet._3.pad1);
1133
1134
if (len < sizeof(res->packet._3.magic10))
1135
return NULL;
1136
memcpy(&res->packet._3.magic10, mem, sizeof(res->packet._3.magic10));
1137
mem += sizeof(res->packet._3.magic10);
1138
len -= sizeof(res->packet._3.magic10);
1139
1140
if (len < sizeof(res->packet._3.pad3))
1141
return NULL;
1142
memcpy(res->packet._3.pad3, mem, sizeof(res->packet._3.pad3));
1143
mem += sizeof(res->packet._3.pad3);
1144
len -= sizeof(res->packet._3.pad3);
1145
1146
if (len < sizeof(res->packet._3.boundport))
1147
return NULL;
1148
memcpy(&res->packet._3.boundport, mem,
1149
sizeof(res->packet._3.boundport));
1150
mem += sizeof(res->packet._3.boundport);
1151
len -= sizeof(res->packet._3.boundport);
1152
1153
if (len < sizeof(res->packet._3.boundaddr))
1154
return NULL;
1155
memcpy(&res->packet._3.boundaddr, mem,
1156
sizeof(res->packet._3.boundaddr));
1157
mem += sizeof(res->packet._3.boundaddr);
1158
len -= sizeof(res->packet._3.boundaddr);
1159
1160
if (len < sizeof(res->packet._3.pad10))
1161
return NULL;
1162
memcpy(res->packet._3.pad10, mem, sizeof(res->packet._3.pad10));
1163
mem += sizeof(res->packet._3.pad10);
1164
len -= sizeof(res->packet._3.pad10);
1165
1166
if (len < sizeof(res->packet._3.magic15))
1167
return NULL;
1168
memcpy(&res->packet._3.magic15, mem, sizeof(res->packet._3.magic15));
1169
mem += sizeof(res->packet._3.magic15);
1170
len -= sizeof(res->packet._3.magic15);
1171
1172
if (len < sizeof(res->packet._3.pad15))
1173
return NULL;
1174
memcpy(res->packet._3.pad15, mem, sizeof(res->packet._3.pad15));
1175
mem += sizeof(res->packet._3.pad15);
1176
len -= sizeof(res->packet._3.pad15);
1177
1178
if (len < sizeof(res->packet._3.NTLMSSP))
1179
return NULL;
1180
memcpy(res->packet._3.NTLMSSP, mem, sizeof(res->packet._3.NTLMSSP));
1181
mem += sizeof(res->packet._3.NTLMSSP);
1182
len -= sizeof(res->packet._3.NTLMSSP);
1183
1184
if (len < sizeof(res->packet._3.magic50))
1185
return NULL;
1186
memcpy(&res->packet._3.magic50, mem, sizeof(res->packet._3.magic50));
1187
mem += sizeof(res->packet._3.magic50);
1188
len -= sizeof(res->packet._3.magic50);
1189
1190
if (len < sizeof(res->packet._3.pad50))
1191
return NULL;
1192
memcpy(res->packet._3.pad50, mem, sizeof(res->packet._3.pad50));
1193
mem += sizeof(res->packet._3.pad50);
1194
len -= sizeof(res->packet._3.pad50);
1195
1196
if (len < sizeof(res->packet._3.magic55))
1197
return NULL;
1198
memcpy(&res->packet._3.magic55, mem, sizeof(res->packet._3.magic55));
1199
mem += sizeof(res->packet._3.magic55);
1200
len -= sizeof(res->packet._3.magic55);
1201
1202
if (len < sizeof(res->packet._3.magic60))
1203
return NULL;
1204
memcpy(&res->packet._3.magic60, mem, sizeof(res->packet._3.magic60));
1205
mem += sizeof(res->packet._3.magic60);
1206
len -= sizeof(res->packet._3.magic60);
1207
1208
if (len < sizeof(res->packet._3.magic65))
1209
return NULL;
1210
memcpy(&res->packet._3.magic65, mem, sizeof(res->packet._3.magic65));
1211
mem += sizeof(res->packet._3.magic65);
1212
len -= sizeof(res->packet._3.magic65);
1213
1214
if (len < sizeof(res->packet._3.pad60))
1215
return NULL;
1216
memcpy(res->packet._3.pad60, mem, sizeof(res->packet._3.pad60));
1217
mem += sizeof(res->packet._3.pad60);
1218
len -= sizeof(res->packet._3.pad60);
1219
1220
if (len < sizeof(res->packet._3.magic70))
1221
return NULL;
1222
memcpy(&res->packet._3.magic70, mem, sizeof(res->packet._3.magic70));
1223
mem += sizeof(res->packet._3.magic70);
1224
len -= sizeof(res->packet._3.magic70);
1225
1226
if (len < sizeof(res->packet._3.magic75))
1227
return NULL;
1228
memcpy(&res->packet._3.magic75, mem, sizeof(res->packet._3.magic75));
1229
mem += sizeof(res->packet._3.magic75);
1230
len -= sizeof(res->packet._3.magic75);
1231
1232
if (len < sizeof(res->packet._3.pad70))
1233
return NULL;
1234
memcpy(res->packet._3.pad70, mem, sizeof(res->packet._3.pad70));
1235
mem += sizeof(res->packet._3.pad70);
1236
len -= sizeof(res->packet._3.pad70);
1237
1238
if (len > sizeof(res->packet._3.ntdomain))
1239
swarnx("hmm, ntdomain length is %d, our max is %d?",
1240
len, sizeof(res->packet._3.ntdomain) - 1);
1241
memcpy(res->packet._3.ntdomain, mem,
1242
MIN(len, sizeof(res->packet._3.ntdomain) - 1));
1243
res->packet._3.ntdomain[len] = NUL;
1244
mem += len;
1245
len -= len;
1246
1247
break;
1248
1249
case MSPROXY_SOMETHING_2_ACK:
1250
case MSPROXY_SOMETHING_2_ACK2:
1251
case MSPROXY_BIND2_ACK:
1252
if (len < sizeof(res->packet._4.pad5))
1253
return NULL;
1254
memcpy(res->packet._4.pad5, mem, sizeof(res->packet._4.pad5));
1255
mem += sizeof(res->packet._4.pad5);
1256
len -= sizeof(res->packet._4.pad5);
1257
break;
1258
1259
case MSPROXY_RESOLVE_ACK: {
1260
if (len < sizeof(res->packet.resolve.addroffset))
1261
return NULL;
1262
memcpy(&res->packet.resolve.addroffset, mem,
1263
sizeof(res->packet.resolve.addroffset));
1264
mem += sizeof(res->packet.resolve.addroffset);
1265
len -= sizeof(res->packet.resolve.addroffset);
1266
1267
if (len < sizeof(res->packet.resolve.pad5))
1268
return NULL;
1269
memcpy(res->packet.resolve.pad5, mem,
1270
sizeof(res->packet.resolve.pad5));
1271
mem += sizeof(res->packet.resolve.pad5);
1272
len -= sizeof(res->packet.resolve.pad5);
1273
1274
mem += res->packet.resolve.addroffset;
1275
1276
if (len < sizeof(res->packet.resolve.hostaddr))
1277
return NULL;
1278
memcpy(&res->packet.resolve.hostaddr, mem,
1279
sizeof(res->packet.resolve.hostaddr));
1280
mem += sizeof(res->packet.resolve.hostaddr);
1281
len -= sizeof(res->packet.resolve.hostaddr);
1282
1283
break;
1284
}
1285
1286
case MSPROXY_CONNECT_ACK:
1287
case MSPROXY_BINDINFO:
1288
if (len < sizeof(res->packet._5.magic1))
1289
return NULL;
1290
memcpy(&res->packet._5.magic1, mem, sizeof(res->packet._5.magic1));
1291
mem += sizeof(res->packet._5.magic1);
1292
len -= sizeof(res->packet._5.magic1);
1293
1294
if (len < sizeof(res->packet._5.pad5))
1295
return NULL;
1296
memcpy(res->packet._5.pad5, mem, sizeof(res->packet._5.pad5));
1297
mem += sizeof(res->packet._5.pad5);
1298
len -= sizeof(res->packet._5.pad5);
1299
1300
if (len < sizeof(res->packet._5.clientport))
1301
return NULL;
1302
memcpy(&res->packet._5.clientport, mem,
1303
sizeof(res->packet._5.clientport));
1304
mem += sizeof(res->packet._5.clientport);
1305
len -= sizeof(res->packet._5.clientport);
1306
1307
if (len < sizeof(res->packet._5.clientaddr))
1308
return NULL;
1309
memcpy(&res->packet._5.clientaddr, mem,
1310
sizeof(res->packet._5.clientaddr));
1311
mem += sizeof(res->packet._5.clientaddr);
1312
len -= sizeof(res->packet._5.clientaddr);
1313
1314
if (len < sizeof(res->packet._5.magic10))
1315
return NULL;
1316
memcpy(&res->packet._5.magic10, mem, sizeof(res->packet._5.magic10));
1317
mem += sizeof(res->packet._5.magic10);
1318
len -= sizeof(res->packet._5.magic10);
1319
1320
if (len < sizeof(res->packet._5.magic15))
1321
return NULL;
1322
memcpy(&res->packet._5.magic15, mem, sizeof(res->packet._5.magic15));
1323
mem += sizeof(res->packet._5.magic15);
1324
len -= sizeof(res->packet._5.magic15);
1325
1326
if (len < sizeof(res->packet._5.serverport))
1327
return NULL;
1328
memcpy(&res->packet._5.serverport, mem,
1329
sizeof(res->packet._5.serverport));
1330
mem += sizeof(res->packet._5.serverport);
1331
len -= sizeof(res->packet._5.serverport);
1332
1333
if (len < sizeof(res->packet._5.srcport))
1334
return NULL;
1335
memcpy(&res->packet._5.srcport, mem, sizeof(res->packet._5.srcport));
1336
mem += sizeof(res->packet._5.srcport);
1337
len -= sizeof(res->packet._5.srcport);
1338
1339
if (len < sizeof(res->packet._5.boundport))
1340
return NULL;
1341
memcpy(&res->packet._5.boundport, mem,
1342
sizeof(res->packet._5.boundport));
1343
mem += sizeof(res->packet._5.boundport);
1344
len -= sizeof(res->packet._5.boundport);
1345
1346
if (len < sizeof(res->packet._5.boundaddr))
1347
return NULL;
1348
memcpy(&res->packet._5.boundaddr, mem,
1349
sizeof(res->packet._5.boundaddr));
1350
mem += sizeof(res->packet._5.boundaddr);
1351
len -= sizeof(res->packet._5.boundaddr);
1352
1353
if (len < sizeof(res->packet._5.pad10))
1354
return NULL;
1355
memcpy(res->packet._5.pad10, mem, sizeof(res->packet._5.pad10));
1356
mem += sizeof(res->packet._5.pad10);
1357
len -= sizeof(res->packet._5.pad10);
1358
1359
break;
1360
1361
case MSPROXY_CONNECT_AUTHFAILED:
1362
case MSPROXY_BIND_AUTHFAILED:
1363
break;
1364
1365
default:
1366
if (ntohs(res->command) >> 8 == MSPROXY_CONNREFUSED
1367
|| ntohs(res->command) >> 12 == MSPROXY_CONNREFUSED)
1368
;
1369
else
1370
slog(LOG_DEBUG, "%s: unknown command in msproxy reply: 0x%x",
1371
function, ntohs(res->command));
1372
}
1373
1374
return mem;
1375
}
1376
1377
static char *
1378
request2mem(req, mem)
1379
const struct msproxy_request_t *req;
1380
char *mem;
1381
{
1382
1383
memcpy(mem, &req->clientid, sizeof(req->clientid));
1384
mem += sizeof(req->clientid);
1385
1386
memcpy(mem, &req->magic25, sizeof(req->magic25));
1387
mem += sizeof(req->magic25);
1388
1389
memcpy(mem, &req->serverid, sizeof(req->serverid));
1390
mem += sizeof(req->serverid);
1391
1392
memcpy(mem, &req->serverack, sizeof(req->serverack));
1393
mem += sizeof(req->serverack);
1394
1395
memcpy(mem, &req->pad10, sizeof(req->pad10));
1396
mem += sizeof(req->pad10);
1397
1398
memcpy(mem, &req->sequence, sizeof(req->sequence));
1399
mem += sizeof(req->sequence);
1400
1401
memcpy(mem, &req->pad11, sizeof(req->pad11));
1402
mem += sizeof(req->pad11);
1403
1404
memcpy(mem, &req->RWSP, sizeof(req->RWSP));
1405
mem += sizeof(req->RWSP);
1406
1407
memcpy(mem, &req->pad15, sizeof(req->pad15));
1408
mem += sizeof(req->pad15);
1409
1410
memcpy(mem, &req->command, sizeof(req->command));
1411
mem += sizeof(req->command);
1412
1413
switch (ntohs(req->command)) {
1414
case MSPROXY_HELLO:
1415
memcpy(mem, &req->packet._1.pad1, sizeof(req->packet._1.pad1));
1416
mem += sizeof(req->packet._1.pad1);
1417
1418
memcpy(mem, &req->packet._1.magic3, sizeof(req->packet._1.magic3));
1419
mem += sizeof(req->packet._1.magic3);
1420
1421
memcpy(mem, &req->packet._1.pad3, sizeof(req->packet._1.pad3));
1422
mem += sizeof(req->packet._1.pad3);
1423
1424
memcpy(mem, &req->packet._1.magic5, sizeof(req->packet._1.magic5));
1425
mem += sizeof(req->packet._1.magic5);
1426
1427
memcpy(mem, &req->packet._1.pad5, sizeof(req->packet._1.pad5));
1428
mem += sizeof(req->packet._1.pad5);
1429
1430
memcpy(mem, &req->packet._1.magic10, sizeof(req->packet._1.magic10));
1431
mem += sizeof(req->packet._1.magic10);
1432
1433
memcpy(mem, &req->packet._1.pad6, sizeof(req->packet._1.pad6));
1434
mem += sizeof(req->packet._1.pad6);
1435
1436
memcpy(mem, &req->packet._1.magic15, sizeof(req->packet._1.magic15));
1437
mem += sizeof(req->packet._1.magic15);
1438
1439
memcpy(mem, &req->packet._1.pad10, sizeof(req->packet._1.pad10));
1440
mem += sizeof(req->packet._1.pad10);
1441
1442
memcpy(mem, &req->packet._1.magic20, sizeof(req->packet._1.magic20));
1443
mem += sizeof(req->packet._1.magic20);
1444
1445
memcpy(mem, &req->packet._1.magic25, sizeof(req->packet._1.magic25));
1446
mem += sizeof(req->packet._1.magic25);
1447
1448
memcpy(mem, &req->packet._1.magic30, sizeof(req->packet._1.magic30));
1449
mem += sizeof(req->packet._1.magic30);
1450
1451
memcpy(mem, &req->packet._1.pad20, sizeof(req->packet._1.pad20));
1452
mem += sizeof(req->packet._1.pad20);
1453
1454
memcpy(mem, &req->packet._1.magic35, sizeof(req->packet._1.magic35));
1455
mem += sizeof(req->packet._1.magic35);
1456
1457
memcpy(mem, &req->packet._1.pad30, sizeof(req->packet._1.pad30));
1458
mem += sizeof(req->packet._1.pad30);
1459
1460
memcpy(mem, &req->packet._1.magic40, sizeof(req->packet._1.magic40));
1461
mem += sizeof(req->packet._1.magic40);
1462
1463
memcpy(mem, &req->packet._1.pad40, sizeof(req->packet._1.pad40));
1464
mem += sizeof(req->packet._1.pad40);
1465
1466
memcpy(mem, &req->packet._1.magic45, sizeof(req->packet._1.magic45));
1467
mem += sizeof(req->packet._1.magic45);
1468
1469
memcpy(mem, &req->packet._1.pad45, sizeof(req->packet._1.pad45));
1470
mem += sizeof(req->packet._1.pad45);
1471
1472
memcpy(mem, &req->packet._1.magic50, sizeof(req->packet._1.magic50));
1473
mem += sizeof(req->packet._1.magic50);
1474
1475
memcpy(mem, &req->packet._1.pad50, sizeof(req->packet._1.pad50));
1476
mem += sizeof(req->packet._1.pad50);
1477
1478
strcpy(mem, req->username);
1479
mem += strlen(req->username) + 1;
1480
1481
strcpy(mem, req->unknown);
1482
mem += strlen(req->unknown) + 1;
1483
1484
strcpy(mem, req->executable);
1485
mem += strlen(req->executable) + 1;
1486
1487
strcpy(mem, req->clienthost);
1488
mem += strlen(req->clienthost) + 1;
1489
1490
break;
1491
1492
case MSPROXY_USERINFO:
1493
memcpy(mem, &req->packet._2.pad1, sizeof(req->packet._2.pad1));
1494
mem += sizeof(req->packet._2.pad1);
1495
1496
memcpy(mem, &req->packet._2.magic3, sizeof(req->packet._2.magic3));
1497
mem += sizeof(req->packet._2.magic3);
1498
1499
memcpy(mem, &req->packet._2.pad3, sizeof(req->packet._2.pad3));
1500
mem += sizeof(req->packet._2.pad3);
1501
1502
memcpy(mem, &req->packet._2.magic5, sizeof(req->packet._2.magic5));
1503
mem += sizeof(req->packet._2.magic5);
1504
1505
memcpy(mem, &req->packet._2.pad5, sizeof(req->packet._2.pad5));
1506
mem += sizeof(req->packet._2.pad5);
1507
1508
memcpy(mem, &req->packet._2.magic10, sizeof(req->packet._2.magic10));
1509
mem += sizeof(req->packet._2.magic10);
1510
1511
memcpy(mem, &req->packet._2.pad10, sizeof(req->packet._2.pad10));
1512
mem += sizeof(req->packet._2.pad10);
1513
1514
memcpy(mem, &req->packet._2.magic15, sizeof(req->packet._2.magic15));
1515
mem += sizeof(req->packet._2.magic15);
1516
1517
memcpy(mem, &req->packet._2.pad15, sizeof(req->packet._2.pad15));
1518
mem += sizeof(req->packet._2.pad15);
1519
1520
memcpy(mem, &req->packet._2.magic20, sizeof(req->packet._2.magic20));
1521
mem += sizeof(req->packet._2.magic20);
1522
1523
memcpy(mem, &req->packet._2.magic25, sizeof(req->packet._2.magic25));
1524
mem += sizeof(req->packet._2.magic25);
1525
1526
memcpy(mem, &req->packet._2.magic30, sizeof(req->packet._2.magic30));
1527
mem += sizeof(req->packet._2.magic30);
1528
1529
memcpy(mem, &req->packet._2.pad20, sizeof(req->packet._2.pad20));
1530
mem += sizeof(req->packet._2.pad20);
1531
1532
memcpy(mem, &req->packet._2.magic35, sizeof(req->packet._2.magic35));
1533
mem += sizeof(req->packet._2.magic35);
1534
1535
memcpy(mem, &req->packet._2.pad25, sizeof(req->packet._2.pad25));
1536
mem += sizeof(req->packet._2.pad25);
1537
1538
memcpy(mem, &req->packet._2.magic35, sizeof(req->packet._2.magic35));
1539
mem += sizeof(req->packet._2.magic35);
1540
1541
memcpy(mem, &req->packet._2.pad25, sizeof(req->packet._2.pad25));
1542
mem += sizeof(req->packet._2.pad25);
1543
1544
memcpy(mem, &req->packet._2.magic50, sizeof(req->packet._2.magic50));
1545
mem += sizeof(req->packet._2.magic50);
1546
1547
memcpy(mem, &req->packet._2.pad50, sizeof(req->packet._2.pad50));
1548
mem += sizeof(req->packet._2.pad50);
1549
1550
memcpy(mem, &req->packet._2.magic55, sizeof(req->packet._2.magic55));
1551
mem += sizeof(req->packet._2.magic55);
1552
1553
memcpy(mem, &req->packet._2.pad55, sizeof(req->packet._2.pad55));
1554
mem += sizeof(req->packet._2.pad55);
1555
1556
memcpy(mem, &req->packet._2.magic60, sizeof(req->packet._2.magic60));
1557
mem += sizeof(req->packet._2.magic60);
1558
1559
strcpy(mem, req->username);
1560
mem += strlen(req->username) + 1;
1561
1562
strcpy(mem, req->unknown);
1563
mem += strlen(req->unknown) + 1;
1564
1565
strcpy(mem, req->executable);
1566
mem += strlen(req->executable) + 1;
1567
1568
strcpy(mem, req->clienthost);
1569
mem += strlen(req->clienthost) + 1;
1570
1571
break;
1572
1573
case MSPROXY_BIND:
1574
case MSPROXY_SOMETHING:
1575
memcpy(mem, &req->packet._3.pad1, sizeof(req->packet._3.pad1));
1576
mem += sizeof(req->packet._3.pad1);
1577
1578
memcpy(mem, &req->packet._3.magic2, sizeof(req->packet._3.magic2));
1579
mem += sizeof(req->packet._3.magic2);
1580
1581
memcpy(mem, &req->packet._3.pad10, sizeof(req->packet._3.pad10));
1582
mem += sizeof(req->packet._3.pad10);
1583
1584
memcpy(mem, &req->packet._3.bindaddr, sizeof(req->packet._3.bindaddr));
1585
mem += sizeof(req->packet._3.bindaddr);
1586
1587
memcpy(mem, &req->packet._3.bindport, sizeof(req->packet._3.bindport));
1588
mem += sizeof(req->packet._3.bindport);
1589
1590
memcpy(mem, &req->packet._3.pad15, sizeof(req->packet._3.pad15));
1591
mem += sizeof(req->packet._3.pad15);
1592
1593
memcpy(mem, &req->packet._3.magic3, sizeof(req->packet._3.magic3));
1594
mem += sizeof(req->packet._3.magic3);
1595
1596
memcpy(mem, &req->packet._3.boundport,
1597
sizeof(req->packet._3.boundport));
1598
mem += sizeof(req->packet._3.boundport);
1599
1600
memcpy(mem, &req->packet._3.pad20, sizeof(req->packet._3.pad20));
1601
mem += sizeof(req->packet._3.pad20);
1602
1603
memcpy(mem, &req->packet._3.NTLMSSP, sizeof(req->packet._3.NTLMSSP));
1604
mem += sizeof(req->packet._3.NTLMSSP);
1605
1606
memcpy(mem, &req->packet._3.magic5, sizeof(req->packet._3.magic5));
1607
mem += sizeof(req->packet._3.magic5);
1608
1609
memcpy(mem, &req->packet._3.pad25, sizeof(req->packet._3.pad25));
1610
mem += sizeof(req->packet._3.pad25);
1611
1612
memcpy(mem, &req->packet._3.magic10, sizeof(req->packet._3.magic10));
1613
mem += sizeof(req->packet._3.magic10);
1614
1615
memcpy(mem, &req->packet._3.magic15, sizeof(req->packet._3.magic15));
1616
mem += sizeof(req->packet._3.magic15);
1617
1618
memcpy(mem, &req->packet._3.magic20, sizeof(req->packet._3.magic20));
1619
mem += sizeof(req->packet._3.magic20);
1620
1621
memcpy(mem, &req->packet._3.pad30, sizeof(req->packet._3.pad30));
1622
mem += sizeof(req->packet._3.pad30);
1623
1624
memcpy(mem, &req->packet._3.magic25, sizeof(req->packet._3.magic25));
1625
mem += sizeof(req->packet._3.magic25);
1626
1627
memcpy(mem, &req->packet._3.magic30, sizeof(req->packet._3.magic30));
1628
mem += sizeof(req->packet._3.magic30);
1629
1630
memcpy(mem, &req->packet._3.pad40, sizeof(req->packet._3.pad40));
1631
mem += sizeof(req->packet._3.pad40);
1632
1633
memcpy(mem, &req->packet._3.magic50, sizeof(req->packet._3.magic50));
1634
mem += sizeof(req->packet._3.magic50);
1635
1636
memcpy(mem, &req->packet._3.pad50, sizeof(req->packet._3.pad50));
1637
mem += sizeof(req->packet._3.pad50);
1638
1639
memcpy(mem, &req->packet._3.magic55, sizeof(req->packet._3.magic55));
1640
mem += sizeof(req->packet._3.magic55);
1641
1642
memcpy(mem, &req->packet._3.pad55, sizeof(req->packet._3.pad55));
1643
mem += sizeof(req->packet._3.pad55);
1644
1645
break;
1646
1647
case MSPROXY_BIND2:
1648
case MSPROXY_SOMETHING_2:
1649
memcpy(mem, &req->packet._4.pad1, sizeof(req->packet._4.pad1));
1650
mem += sizeof(req->packet._4.pad1);
1651
1652
memcpy(mem, &req->packet._4.magic1, sizeof(req->packet._4.magic1));
1653
mem += sizeof(req->packet._4.magic1);
1654
1655
memcpy(mem, &req->packet._4.magic2, sizeof(req->packet._4.magic2));
1656
mem += sizeof(req->packet._4.magic2);
1657
1658
memcpy(mem, &req->packet._4.pad2, sizeof(req->packet._4.pad2));
1659
mem += sizeof(req->packet._4.pad2);
1660
1661
memcpy(mem, &req->packet._4.magic3, sizeof(req->packet._4.magic3));
1662
mem += sizeof(req->packet._4.magic3);
1663
1664
memcpy(mem, &req->packet._4.pad3, sizeof(req->packet._4.pad3));
1665
mem += sizeof(req->packet._4.pad3);
1666
1667
memcpy(mem, &req->packet._4.magic4, sizeof(req->packet._4.magic4));
1668
mem += sizeof(req->packet._4.magic4);
1669
1670
memcpy(mem, &req->packet._4.boundport,
1671
sizeof(req->packet._4.boundport));
1672
mem += sizeof(req->packet._4.boundport);
1673
1674
memcpy(mem, &req->packet._4.pad4, sizeof(req->packet._4.pad4));
1675
mem += sizeof(req->packet._4.pad4);
1676
1677
memcpy(mem, &req->packet._4.NTLMSSP, sizeof(req->packet._4.NTLMSSP));
1678
mem += sizeof(req->packet._4.NTLMSSP);
1679
1680
memcpy(mem, &req->packet._4.magic5, sizeof(req->packet._4.magic5));
1681
mem += sizeof(req->packet._4.magic5);
1682
1683
memcpy(mem, &req->packet._4.pad5, sizeof(req->packet._4.pad5));
1684
mem += sizeof(req->packet._4.pad5);
1685
1686
memcpy(mem, &req->packet._4.magic10, sizeof(req->packet._4.magic10));
1687
mem += sizeof(req->packet._4.magic10);
1688
1689
memcpy(mem, &req->packet._4.magic10, sizeof(req->packet._4.magic10));
1690
mem += sizeof(req->packet._4.magic10);
1691
1692
memcpy(mem, &req->packet._4.magic20, sizeof(req->packet._4.magic20));
1693
mem += sizeof(req->packet._4.magic20);
1694
1695
memcpy(mem, &req->packet._4.pad10, sizeof(req->packet._4.pad10));
1696
mem += sizeof(req->packet._4.pad10);
1697
1698
memcpy(mem, &req->packet._4.magic30, sizeof(req->packet._4.magic30));
1699
mem += sizeof(req->packet._4.magic30);
1700
1701
memcpy(mem, &req->packet._4.pad15, sizeof(req->packet._4.pad15));
1702
mem += sizeof(req->packet._4.pad15);
1703
1704
memcpy(mem, &req->packet._4.magic35, sizeof(req->packet._4.magic35));
1705
mem += sizeof(req->packet._4.magic35);
1706
1707
memcpy(mem, &req->packet._4.magic40, sizeof(req->packet._4.magic40));
1708
mem += sizeof(req->packet._4.magic40);
1709
1710
memcpy(mem, &req->packet._4.magic45, sizeof(req->packet._4.magic45));
1711
mem += sizeof(req->packet._4.magic45);
1712
1713
memcpy(mem, &req->packet._4.pad20, sizeof(req->packet._4.pad20));
1714
mem += sizeof(req->packet._4.pad20);
1715
1716
memcpy(mem, &req->packet._4.magic50, sizeof(req->packet._4.magic50));
1717
mem += sizeof(req->packet._4.magic50);
1718
1719
memcpy(mem, &req->packet._4.magic55, sizeof(req->packet._4.magic55));
1720
mem += sizeof(req->packet._4.magic55);
1721
1722
memcpy(mem, &req->packet._4.magic60, sizeof(req->packet._4.magic60));
1723
mem += sizeof(req->packet._4.magic60);
1724
1725
memcpy(mem, &req->packet._4.pad25, sizeof(req->packet._4.pad25));
1726
mem += sizeof(req->packet._4.pad25);
1727
1728
memcpy(mem, &req->packet._4.magic65, sizeof(req->packet._4.magic65));
1729
mem += sizeof(req->packet._4.magic65);
1730
1731
memcpy(mem, &req->packet._4.magic70, sizeof(req->packet._4.magic70));
1732
mem += sizeof(req->packet._4.magic70);
1733
1734
memcpy(mem, &req->packet._4.magic75, sizeof(req->packet._4.magic75));
1735
mem += sizeof(req->packet._4.magic75);
1736
1737
break;
1738
1739
case MSPROXY_RESOLVE:
1740
memcpy(mem, &req->packet.resolve.hostlength,
1741
sizeof(req->packet.resolve.hostlength));
1742
mem += sizeof(req->packet.resolve.hostlength);
1743
1744
memcpy(mem, &req->packet.resolve.pad1,
1745
sizeof(req->packet.resolve.pad1));
1746
mem += sizeof(req->packet.resolve.pad1);
1747
1748
memcpy(mem, &req->packet.resolve.host,
1749
(size_t)req->packet.resolve.hostlength);
1750
mem += req->packet.resolve.hostlength;
1751
1752
break;
1753
1754
case MSPROXY_LISTEN:
1755
case MSPROXY_CONNECT:
1756
memcpy(mem, &req->packet._5.magic1, sizeof(req->packet._5.magic1));
1757
mem += sizeof(req->packet._5.magic1);
1758
1759
memcpy(mem, &req->packet._5.pad1, sizeof(req->packet._5.pad1));
1760
mem += sizeof(req->packet._5.pad1);
1761
1762
memcpy(mem, &req->packet._5.magic3, sizeof(req->packet._5.magic3));
1763
mem += sizeof(req->packet._5.magic3);
1764
1765
memcpy(mem, &req->packet._5.pad5, sizeof(req->packet._5.pad5));
1766
mem += sizeof(req->packet._5.pad5);
1767
1768
memcpy(mem, &req->packet._5.magic6, sizeof(req->packet._5.magic6));
1769
mem += sizeof(req->packet._5.magic6);
1770
1771
memcpy(mem, &req->packet._5.destport, sizeof(req->packet._5.destport));
1772
mem += sizeof(req->packet._5.destport);
1773
1774
memcpy(mem, &req->packet._5.destaddr, sizeof(req->packet._5.destaddr));
1775
mem += sizeof(req->packet._5.destaddr);
1776
1777
memcpy(mem, &req->packet._5.pad10, sizeof(req->packet._5.pad10));
1778
mem += sizeof(req->packet._5.pad10);
1779
1780
memcpy(mem, &req->packet._5.magic10, sizeof(req->packet._5.magic10));
1781
mem += sizeof(req->packet._5.magic10);
1782
1783
memcpy(mem, &req->packet._5.pad15, sizeof(req->packet._5.pad15));
1784
mem += sizeof(req->packet._5.pad15);
1785
1786
memcpy(mem, &req->packet._5.srcport, sizeof(req->packet._5.srcport));
1787
mem += sizeof(req->packet._5.srcport);
1788
1789
memcpy(mem, &req->packet._5.pad20, sizeof(req->packet._5.pad20));
1790
mem += sizeof(req->packet._5.pad20);
1791
strcpy(mem, req->executable);
1792
1793
break;
1794
1795
case MSPROXY_BINDINFO_ACK:
1796
case MSPROXY_CONNECTED:
1797
memcpy(mem, &req->packet._6.magic1, sizeof(req->packet._6.magic1));
1798
mem += sizeof(req->packet._6.magic1);
1799
1800
memcpy(mem, req->packet._6.pad5, sizeof(req->packet._6.pad5));
1801
mem += sizeof(req->packet._6.pad5);
1802
1803
memcpy(mem, &req->packet._6.magic5, sizeof(req->packet._6.magic5));
1804
mem += sizeof(req->packet._6.magic5);
1805
1806
memcpy(mem, &req->packet._6.magic10, sizeof(req->packet._6.magic10));
1807
mem += sizeof(req->packet._6.magic10);
1808
1809
memcpy(mem, req->packet._6.pad10, sizeof(req->packet._6.pad10));
1810
mem += sizeof(req->packet._6.pad10);
1811
1812
memcpy(mem, &req->packet._6.magic15, sizeof(req->packet._6.magic15));
1813
mem += sizeof(req->packet._6.magic15);
1814
1815
memcpy(mem, &req->packet._6.magic16, sizeof(req->packet._6.magic16));
1816
mem += sizeof(req->packet._6.magic16);
1817
1818
memcpy(mem, &req->packet._6.magic20, sizeof(req->packet._6.magic20));
1819
mem += sizeof(req->packet._6.magic20);
1820
1821
memcpy(mem, &req->packet._6.clientport,
1822
sizeof(req->packet._6.clientport));
1823
mem += sizeof(req->packet._6.clientport);
1824
1825
memcpy(mem, &req->packet._6.clientaddr,
1826
sizeof(req->packet._6.clientaddr));
1827
mem += sizeof(req->packet._6.clientaddr);
1828
1829
memcpy(mem, &req->packet._6.magic30, sizeof(req->packet._6.magic30));
1830
mem += sizeof(req->packet._6.magic30);
1831
1832
memcpy(mem, &req->packet._6.magic35, sizeof(req->packet._6.magic35));
1833
mem += sizeof(req->packet._6.magic35);
1834
1835
memcpy(mem, &req->packet._6.serverport,
1836
sizeof(req->packet._6.serverport));
1837
mem += sizeof(req->packet._6.serverport);
1838
1839
memcpy(mem, &req->packet._6.srcport, sizeof(req->packet._6.srcport));
1840
mem += sizeof(req->packet._6.srcport);
1841
1842
memcpy(mem, &req->packet._6.boundport,
1843
sizeof(req->packet._6.boundport));
1844
mem += sizeof(req->packet._6.boundport);
1845
1846
memcpy(mem, &req->packet._6.boundaddr,
1847
sizeof(req->packet._6.boundaddr));
1848
mem += sizeof(req->packet._6.boundaddr);
1849
1850
memcpy(mem, req->packet._6.pad30, sizeof(req->packet._6.pad30));
1851
mem += sizeof(req->packet._6.pad30);
1852
1853
break;
1854
1855
case MSPROXY_SESSIONEND:
1856
break;
1857
1858
default:
1859
SERRX(req->command);
1860
}
1861
1862
return mem;
1863
}
1864
1865
void
1866
msproxy_sessionsend(void)
1867
{
1868
const char *function = "msproxy_sessionsend()";
1869
int i, max;
1870
struct socksfd_t *socksfd;
1871
1872
slog(LOG_DEBUG, function);
1873
1874
for (i = 0, max = getdtablesize(); i < max; ++i) {
1875
if ((socksfd = socks_getaddr((unsigned int)i)) == NULL)
1876
continue;
1877
1878
if (socksfd->state.version != MSPROXY_V2)
1879
continue;
1880
1881
msproxy_sessionend(socksfd->control, &socksfd->state.msproxy);
1882
}
1883
}
1884
1885
static void
1886
msproxy_sessionend(s, msproxy)
1887
int s;
1888
struct msproxy_state_t *msproxy;
1889
{
1890
const char *function = "msproxy_sessionend()";
1891
struct msproxy_request_t req;
1892
1893
slog(LOG_DEBUG, function);
1894
1895
bzero(&req, sizeof(req));
1896
*req.username = NUL;
1897
*req.unknown = NUL;
1898
*req.executable = NUL;
1899
*req.clienthost = NUL;
1900
req.clientid = msproxy->clientid;
1901
req.serverid = msproxy->serverid;
1902
req.command = htons(MSPROXY_SESSIONEND);
1903
1904
send_msprequest(s, msproxy, &req);
1905
}
1906
1907
/* ARGSUSED */
1908
static void
1909
msproxy_keepalive(sig)
1910
int sig;
1911
{
1912
const char *function = "msproxy_keepalive()";
1913
struct msproxy_request_t req;
1914
struct msproxy_response_t res;
1915
struct socksfd_t *socksfd;
1916
int i, max;
1917
1918
slog(LOG_DEBUG, function);
1919
1920
for (i = 0, max = getdtablesize(); i < max; ++i) {
1921
if ((socksfd = socks_getaddr((unsigned int)i)) == NULL)
1922
continue;
1923
1924
if (socksfd->state.version != MSPROXY_V2
1925
|| socksfd->state.inprogress)
1926
continue;
1927
1928
slog(LOG_DEBUG, "%s: sending keepalive packet", function);
1929
1930
bzero(&req, sizeof(req));
1931
req.clientid = socksfd->state.msproxy.clientid;
1932
req.serverid = socksfd->state.msproxy.serverid;
1933
req.command = htons(MSPROXY_HELLO);
1934
1935
if (send_msprequest(socksfd->control, &socksfd->state.msproxy, &req)
1936
== -1)
1937
return;
1938
1939
if (recv_mspresponse(socksfd->control, &socksfd->state.msproxy, &res)
1940
== -1)
1941
return;
1942
}
1943
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1