开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
msproxy_clientprotocol.c
资源名称：dante-1.1.1.tar.gz　[点击查看]
上传用户：zm130024
上传日期：2007-01-04
资源大小：432k
文件大小：57k
源码类别：

代理服务器

开发平台：

Unix_Linux

msproxy_clientprotocol.c：源码内容
  1. /*
  2.  * Copyright (c) 1997, 1998, 1999
  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.  *  Gaustadal閑n 21
  36.  *  N-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.  */
  44. /*
  45.  * This code is terrible so hopefully it will match the protocol.
  46.  */
  48. #include "common.h"
  50. static const char rcsid[] =
  51. "$Id: msproxy_clientprotocol.c,v 1.22 1999/09/02 10:41:41 michaels Exp $";
  53. static char executable[] = "TELNET.EXE";
  54. static struct sigaction oldsigio;
  56. __BEGIN_DECLS
  58. static int
  59. msproxy_connect __P((int s, int control, struct socks_t *packet));
  61. static int
  62. msproxy_bind __P((int s, int control, struct socks_t *packet));
  64. static char *
  65. mem2response __P((struct msproxy_response_t *res, char *mem, size_t len));
  67. static char *
  68. request2mem __P((const struct msproxy_request_t *req, char *mem));
  70. static void
  71. msproxy_sessionsend __P((void));
  72. /*
  73.  * Terminates all msproxy sessions.
  74.  */
  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.  */
  82. static void
  83. msproxy_keepalive __P((int signal));
  84. /*
  85.  * Sends a keepalive packet on behalf of all established sessions.
  86.  */
  88. static void
  89. sigio __P((int sig));
  91. __END_DECLS
  93. int
  94. msproxy_init(void)
  95. {
  96. const char *function = "msproxy_init()";
  97. struct itimerval timerval;
  98. struct sigaction sigact, oldsigact;
  100. if (atexit(msproxy_sessionsend) != 0) {
  101. swarn("%s: atexit()", function);
  102. return -1;
  103. }
  105. if (sigaction(SIGALRM, NULL, &oldsigact) != 0) {
  106. swarn("%s: sigaction(SIGALRM)", function);
  107. return -1;
  108. }
  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. }
  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. }
  126. timerval.it_value.tv_sec = MSPROXY_PINGINTERVAL;
  127. timerval.it_value.tv_usec = 0;
  128. timerval.it_interval = timerval.it_value;
  130. if (setitimer(ITIMER_REAL, &timerval, NULL) != 0) {
  131. swarn("%s: setitimer()", function);
  132. return -1;
  133. }
  135. srand((unsigned int)time(NULL) * getpid());
  137. return 0;
  138. }
  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. struct msproxy_request_t req;
  148. struct msproxy_response_t res;
  149. int p;
  151. slog(LOG_DEBUG, "%s: packet #1", function);
  153. bzero(&req, sizeof(req));
  154. req.clientid = htonl(0x0a000000);
  155. req.command = htons(MSPROXY_HELLO);
  157. /* in case we don't get something more sensible. */
  158. packet->res.version = packet->req.version;
  159. packet->res.reply = MSPROXY_FAILURE;
  161. switch (packet->req.command) {
  162. case SOCKS_BIND:
  163. #if 1
  164. req.packet._1.magic5 = htons(0x4800);
  165. req.packet._1.magic10 = htons(0x1400);
  166. req.packet._1.magic15 = htons(0x0400);
  167. req.packet._1.magic20 = htons(0x5704);
  168. req.packet._1.magic25 = htons(0x0004);
  169. req.packet._1.magic30 = htons(0x0100);
  170. req.packet._1.magic35 = htons(0x4a02);
  171. req.packet._1.magic40 = htons(0x3000);
  172. req.packet._1.magic45 = htons(0x4100);
  173. req.packet._1.magic50 = htons(0x3900);
  174. #endif
  175. break;
  177. case SOCKS_CONNECT:
  178. #if 0
  179. req.packet._1.magic5 = htons(0x4b00);
  180. req.packet._1.magic10 = htons(0x1400);
  181. req.packet._1.magic15 = htons(0x0400);
  182. req.packet._1.magic20 = htons(0x5704);
  183. req.packet._1.magic25 = htons(0x0004);
  184. req.packet._1.magic30 = htons(0x0100);
  185. req.packet._1.magic35 = htons(0x4a02);
  186. req.packet._1.magic40 = htons(0x3000);
  187. req.packet._1.magic45 = htons(0x4400);
  188. req.packet._1.magic50 = htons(0x3900);
  189. #endif
  190. break;
  192. case SOCKS_UDPASSOCIATE:
  193. SERRX(packet->req.command);
  194. /* NOTREACHED */
  196. default:
  197. SERRX(packet->req.command);
  198. }
  200. if (socks_getusername(&packet->gw.host, req.username, sizeof(req.username))
  201. == NULL)
  202. return -1;
  204. *req.unknown = NUL;
  206. strncpy(req.executable, executable, sizeof(req.executable) - 1);
  207. req.executable[sizeof(req.executable) - 1] = NUL;
  209. *req.clienthost = NUL;
  211. #if 0
  212. strncpy(req.clienthost, "foo", sizeof(req.clienthost) - 1);
  213. req.clienthost[sizeof(req.clienthost) - 1] = NUL;
  214. #endif
  216. if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
  217. return -1;
  219. if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
  220. return -1;
  222. if (strcmp(res.RWSP, "RWSP") != 0)
  223. serrx(EXIT_FAILURE, "expected "RWSP", got "%s"",
  224. str2vis(res.RWSP, sizeof(res.RWSP)));
  226. if (ntohs(res.command) >> 8 != 0x10)
  227. serrx(EXIT_FAILURE, "expected res.command = 10??, is %x",
  228. ntohs(res.command));
  230. packet->state.msproxy.controladdr.sin_family = AF_INET;
  231. packet->state.msproxy.controladdr.sin_port = res.packet._1.udpport;
  232. packet->state.msproxy.controladdr.sin_addr.s_addr = res.packet._1.udpaddr;
  234. packet->state.msproxy.clientid = htonl(rand());
  235. packet->state.msproxy.serverid = res.serverid;
  237. slog(LOG_DEBUG, "%s: clientid: 0x%x, serverid: 0x%0x",
  238. function, packet->state.msproxy.clientid, packet->state.msproxy.serverid);
  240. /* LINTED pointer casts may be troublesome */
  241. slog(LOG_DEBUG, "%s: msproxy controladdress: %s",
  242. function,
  243. sockaddr2string((struct sockaddr *)&packet->state.msproxy.controladdr,
  244. NULL, 0));
  247. slog(LOG_DEBUG, "%s: packet #2", function);
  249. /* almost identical. */
  250. req.clientid = packet->state.msproxy.clientid;
  251. req.serverid = packet->state.msproxy.serverid;
  253. if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
  254. return -1;
  256. if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
  257. return -1;
  259. if (res.serverid != packet->state.msproxy.serverid)
  260. serrx(EXIT_FAILURE, "expected serverid = 0x%x, is 0x%x",
  261. packet->state.msproxy.serverid, res.serverid);
  263. if (res.sequence != 0x01)
  264. serrx(EXIT_FAILURE, "expected res.sequence = 0x%x, is 0x%x",
  265. 0x01, res.sequence);
  267. if (ntohs(res.command) != MSPROXY_USERINFO_ACK)
  268. serrx(EXIT_FAILURE, "expected res.command = 0x%x, is 0x%x",
  269. MSPROXY_USERINFO_ACK, ntohs(res.command));
  271. switch (packet->req.command) {
  272. case SOCKS_BIND:
  273. p = msproxy_bind(s, control, packet);
  274. break;
  276. case SOCKS_CONNECT:
  277. p = msproxy_connect(s, control, packet);
  278. break;
  280. case SOCKS_UDPASSOCIATE:
  281. default:
  282. SERRX(packet->req.command);
  283. }
  285. return p;
  286. }
  288. static int
  289. msproxy_connect(s, control, packet)
  290. int s;
  291. int control;
  292. struct socks_t *packet;
  293. {
  294. const char *function = "msproxy_connect()";
  295. struct msproxy_request_t req;
  296. struct msproxy_response_t res;
  297. struct sockaddr_in addr;
  298. socklen_t len;
  300. slog(LOG_DEBUG, function);
  302. #if 0
  304. bzero(&req, sizeof(req));
  305. req.clientid = packet->state.msproxy.clientid;
  306. req.serverid = packet->state.msproxy.serverid;
  307. req.command = htons(MSPROXY_SOMETHING);
  308. memcpy(req.packet._3.NTLMSSP, "NTLMSSP", sizeof("NTLMSSP"));
  309. req.packet._3.bindaddr = htonl(0x02000000);
  310. req.packet._3.magic5 = htons(0x0100);
  311. req.packet._3.magic10 = htons(0x9682);
  312. #if 0
  313. req.packet._3.magic50 = htons(0x3000);
  314. req.packet._3.magic55 = htons(0x3000);
  315. #endif
  317. if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
  318. return -1;
  320. if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
  321. return -1;
  323. if (res.serverid != packet->state.msproxy.serverid)
  324. serrx(EXIT_FAILURE, "expected serverid = 0x%x, is 0x%x",
  325. packet->state.msproxy.serverid, res.serverid);
  327. if (ntohs(res.command) != MSPROXY_SOMETHING_1_ACK)
  328. serrx(EXIT_FAILURE, "expected res.command = 0x%x, is 0x%x",
  329. MSPROXY_SOMETHING_1_ACK, ntohs(res.command));
  331. slog(LOG_DEBUG, "%s: ntdomain: "%s"", function, res.packet._3.ntdomain);
  334. slog(LOG_DEBUG, "%s: packet #4", function);
  336. bzero(&req, sizeof(req));
  337. req.clientid = packet->state.msproxy.clientid;
  338. req.serverid = packet->state.msproxy.serverid;
  339. req.command = htons(MSPROXY_SOMETHING_2);
  340. #if 0
  341. memcpy(req.packet._4.NTLMSSP, "NTLMSSP", sizeof("NTLMSSP"));
  342. req.packet._4.magic3 = htons(0x0200);
  343. req.packet._4.magic5 = htons(0x0300);
  344. req.packet._4.magic10 = htons(0x1800);
  345. req.packet._4.magic15 = htons(0x1800);
  346. req.packet._4.magic20 = htons(0x4900);
  347. req.packet._4.magic30 = htons(0x6100);
  348. req.packet._4.magic35 = htons(0x0800);
  349. req.packet._4.magic40 = htons(0x0800);
  350. req.packet._4.magic45 = htons(0x3400);
  351. req.packet._4.magic50 = htons(0x0700);
  352. req.packet._4.magic55 = htons(0x0700);
  353. req.packet._4.magic60 = htons(0x3c00);
  354. req.packet._4.magic65 = htons(0x0600);
  355. req.packet._4.magic70 = htons(0x0600);
  356. req.packet._4.magic75 = htons(0x4300);
  357. #endif
  359. if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
  360. return -1;
  362. if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
  363. return -1;
  365. if (res.serverid != packet->state.msproxy.serverid)
  366. serrx(EXIT_FAILURE, "expected res.serverid = 0x%x, is 0x%x",
  367. packet->state.msproxy.serverid, res.serverid);
  369. if (res.clientack != 0x01)
  370. serrx(EXIT_FAILURE, "expected res.clientack = 0x%x, is 0x%x",
  371. 0x01, res.clientack);
  373. if (ntohs(res.command) >> 8 != 0x47)
  374. serrx(EXIT_FAILURE, "expected res.command = 47??, is 0x%x",
  375. ntohs(res.command));
  376. #endif
  378. switch (packet->req.host.atype) {
  379. case SOCKS_ADDR_IPV4:
  380. /* LINTED pointer casts may be troublesome */
  381. sockshost2sockaddr(&packet->req.host, (struct sockaddr *)&addr);
  382. break;
  384. case SOCKS_ADDR_DOMAIN:
  385. slog(LOG_DEBUG, "%s: resolve packet", function);
  387. bzero(&req, sizeof(req));
  388. req.clientid = packet->state.msproxy.clientid;
  389. req.serverid = packet->state.msproxy.serverid;
  391. req.command = htons(MSPROXY_RESOLVE);
  392. req.packet.resolve.hostlength
  393. = (unsigned char)(strlen(packet->req.host.addr.domain) + 1);
  394. memcpy(&req.packet.resolve.host, packet->req.host.addr.domain,
  395. (size_t)req.packet.resolve.hostlength);
  397. if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
  398. return -1;
  400. if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
  401. return -1;
  403. if (ntohs(res.command) != MSPROXY_RESOLVE_ACK)
  404. serrx(EXIT_FAILURE, "expected res.command = 0x%x, is 0x%x",
  405. MSPROXY_RESOLVE_ACK, ntohs(res.command));
  407. addr.sin_addr.s_addr = res.packet.resolve.hostaddr;
  408. slog(LOG_DEBUG, "%s: ip address of %s: %s",
  409. function, packet->req.host.addr.domain, inet_ntoa(addr.sin_addr));
  411. break;
  413. default:
  414. SERRX(packet->req.host.atype);
  415. }
  418. slog(LOG_DEBUG, "%s: packet #5", function);
  420. bzero(&req, sizeof(req));
  421. req.clientid = packet->state.msproxy.clientid;
  422. req.serverid = packet->state.msproxy.serverid;
  423. req.command = htons(MSPROXY_CONNECT);
  424. req.packet._5.magic6 = htons(0x0200);
  425. req.packet._5.destport = packet->req.host.port;
  426. req.packet._5.destaddr = addr.sin_addr.s_addr;
  428. /*
  429.  * need to tell server what port we will connect from, so if socket
  430.  * is not bound, bind it.
  431.  */
  433. len = sizeof(addr);
  434. /* LINTED pointer casts may be troublesome */
  435. if (getsockname(s, (struct sockaddr *)&addr, &len) != 0)
  436. return -1;
  438. if (!ADDRISBOUND(addr)) {
  439. /*
  440.  * Don't have any specific preference for what address to bind and
  441.  * proxyserver only expects to be told port.
  442.  */
  444. addr.sin_addr.s_addr = htonl(INADDR_ANY);
  445. /* LINTED pointer casts may be troublesome */
  446. if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) != 0)
  447. return -1;
  449. len = sizeof(addr);
  450. /* LINTED pointer casts may be troublesome */
  451. if (getsockname(s, (struct sockaddr *)&addr, &len) != 0)
  452. return -1;
  453. }
  454. req.packet._5.srcport = addr.sin_port;
  456. if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
  457. return -1;
  459. if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
  460. return -1;
  462. if (ntohs(res.command) != MSPROXY_CONNECT_ACK) {
  463. swarnx("expected res.command = 0x%x, is 0x%x",
  464. MSPROXY_CONNECT_ACK, ntohs(res.command));
  465. packet->res.reply = MSPROXY_NOTALLOWED;
  466. return -1;
  467. }
  469. packet->res.host.atype = SOCKS_ADDR_IPV4;
  470. packet->res.host.port = res.packet._5.clientport;
  471. packet->res.host.addr.ipv4.s_addr = res.packet._5.clientaddr;
  473. if (socks_connect(s, &packet->res.host) != 0) {
  474. swarn("%s: failed to connect to %s",
  475. function, sockshost2string(&packet->res.host, NULL, 0));
  476. return -1;
  477. }
  478. else
  479. slog(LOG_DEBUG, "%s: connected to %s",
  480. function, sockshost2string(&packet->res.host, NULL, 0));
  482. packet->res.host.atype = SOCKS_ADDR_IPV4;
  483. packet->res.host.port = res.packet._5.clientport;
  484. packet->res.host.addr.ipv4.s_addr = res.packet._5.clientaddr;
  486. /* LINTED pointer casts may be troublesome */
  487. slog(LOG_DEBUG, "%s: server will use as source address: %s",
  488. function, sockshost2string(&packet->res.host, NULL, 0));
  491. slog(LOG_DEBUG, "%s: packet #6", function);
  493. bzero(&req, sizeof(req));
  494. req.clientid = packet->state.msproxy.clientid;
  495. req.serverid = packet->state.msproxy.serverid;
  496. req.command = htons(MSPROXY_CONNECTED);
  498. if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
  499. return -1;
  502. /* make response look sensible. */
  503. packet->res.version = packet->req.version;
  504. packet->res.reply = MSPROXY_SUCCESS;
  505. packet->res.flag = 0;
  506. packet->res.auth = NULL;
  508. return 0;
  509. }
  511. static int
  512. msproxy_bind(s, control, packet)
  513. int s;
  514. int control;
  515. struct socks_t *packet;
  516. {
  517. const char *function = "msproxy_bind()";
  518. struct msproxy_request_t req;
  519. struct msproxy_response_t res;
  520. struct sockaddr_in addr;
  521. socklen_t len;
  523. slog(LOG_DEBUG, function);
  525. bzero(&req, sizeof(req));
  526. req.clientid = packet->state.msproxy.clientid;
  527. req.serverid = packet->state.msproxy.serverid;
  528. req.command = htons(MSPROXY_BIND);
  529. req.packet._3.magic2 = htons(0x0100);
  530. req.packet._3.bindaddr = packet->req.host.addr.ipv4.s_addr;
  531. req.packet._3.bindport = packet->req.host.port;
  532. req.packet._3.magic3 = htons(0x0200);
  533. len = sizeof(addr);
  534. /* LINTED pointer casts may be troublesome */
  535. if (getsockname(s, (struct sockaddr *)&addr, &len) != 0)
  536. return -1;
  537. req.packet._3.boundport = addr.sin_port;
  539. if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
  540. return -1;
  542. if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
  543. return -1;
  545. if (res.serverid != packet->state.msproxy.serverid)
  546. serrx(EXIT_FAILURE, "expected serverid = 0x%x, is 0x%x",
  547. packet->state.msproxy.serverid, res.serverid);
  549. if (ntohs(res.command) != MSPROXY_BIND_ACK) {
  550. swarnx("expected res.command = 0x%x, is 0x%x",
  551. MSPROXY_BIND_ACK, ntohs(res.command));
  552. packet->res.reply = MSPROXY_NOTALLOWED;
  553. return -1;
  554. }
  556. packet->state.msproxy.bindid = res.packet._3.magic10;
  557. packet->res.host.atype = SOCKS_ADDR_IPV4;
  558. packet->res.host.port = res.packet._3.boundport;
  559. packet->res.host.addr.ipv4.s_addr = res.packet._3.boundaddr;
  561. slog(LOG_DEBUG, "%s: server bound for us: %s",
  562. function, sockshost2string(&packet->res.host, NULL, 0));
  565. slog(LOG_DEBUG, "%s: packet #4", function);
  567. bzero(&req, sizeof(req));
  568. req.clientid = packet->state.msproxy.clientid;
  569. req.serverid = packet->state.msproxy.serverid;
  570. req.command = htons(MSPROXY_BIND2);
  571. req.packet._4.magic1 = htons(0x0100);
  572. req.packet._4.magic2 = packet->state.msproxy.bindid;
  573. req.packet._4.magic3 = htons(0x0500);
  574. memcpy(req.packet._4.pad3 + 2, &addr.sin_port, sizeof(addr.sin_port));
  575. req.packet._4.magic4 = htons(0x0200);
  576. req.packet._4.boundport = addr.sin_port;
  578. if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
  579. return -1;
  581. if (recv_mspresponse(control, &packet->state.msproxy, &res) == -1)
  582. return -1;
  584. if (res.serverid != packet->state.msproxy.serverid)
  585. serrx(EXIT_FAILURE, "expected res.serverid = 0x%x, is 0x%x",
  586. packet->state.msproxy.serverid, res.serverid);
  588. if (res.clientack != 0x01)
  589. serrx(EXIT_FAILURE, "expected res.clientack = 0x%x, is 0x%x",
  590. 0x01, res.clientack);
  592. if (ntohs(res.command) != MSPROXY_BIND2_ACK) {
  593. swarnx("expected res.command = %x, is 0x%x",
  594. MSPROXY_BIND2_ACK, ntohs(res.command));
  595. return -1;
  596. }
  599. slog(LOG_DEBUG, "%s: packet #5", function);
  601. bzero(&req, sizeof(req));
  602. req.clientid = packet->state.msproxy.clientid;
  603. req.serverid = packet->state.msproxy.serverid;
  604. req.command = htons(MSPROXY_LISTEN);
  605. req.packet._5.magic6 = htons(0x0200);
  606. req.packet._5.destport = packet->res.host.port;
  607. req.packet._5.destaddr = packet->res.host.addr.ipv4.s_addr;
  609. if (send_msprequest(control, &packet->state.msproxy, &req) == -1)
  610. return -1;
  612. /*
  613.  * When the server accepts the client, it will send us a new
  614.  * controlpacket.  That will be caught in sigio().
  615.  */
  617. slog(LOG_DEBUG, "%s: waiting for forwarded connection...", function);
  619. /* make response look sensible. */
  620. packet->res.version = packet->req.version;
  621. packet->res.reply = MSPROXY_SUCCESS;
  622. packet->res.flag = 0;
  623. packet->res.auth = NULL;
  625. return 0;
  626. }
  628. int
  629. msproxy_sigio(s)
  630. int s;
  631. {
  632. const char *function = "msproxy_sigio()";
  633. static int init;
  634. const int errno_s = errno;
  635. struct socksfd_t *socksfd;
  636. int p;
  638. /*
  639.  * The msproxy protocol sends a udp packet which we must ack
  640.  * before it will connect to us.  We set up the controlsocket
  641.  * for signaldriven i/o so we can ack it asynchronously.
  642.  *
  643.  */
  645. SASSERTX(socks_addrisok((unsigned int)s));
  646. socksfd = socks_getaddr((unsigned int)s);
  647. SASSERTX(socksfd->state.version == MSPROXY_V2);
  649. if (!init) { /* could be smarter about this... */
  650. struct sigaction sigact;
  652. sigemptyset(&sigact.sa_mask);
  653. sigact.sa_flags = SA_RESTART;
  654. sigact.sa_handler = sigio;
  655. if (sigaction(SIGIO, &sigact, &oldsigio) != 0)
  656. return -1;
  658. init = 1;
  659. }
  661. if (fcntl(socksfd->control, F_SETOWN, getpid()) == -1)
  662. return -1;
  664. p = 1;
  665. if (ioctl(socksfd->control, FIOASYNC, &p) == -1)
  666. return -1;
  668. slog(LOG_DEBUG, "%s: set up sigio for %d", function, socksfd->control);
  670. errno = errno_s;
  671. return 0;
  672. }
  674. /* ARGSUSED */
  675. static void
  676. sigio(sig)
  677. int sig;
  678. {
  679. const char *function = "sigio()";
  680. const int errno_s = errno;
  681. int i, max, dset;
  682. struct socksfd_t *socksfd;
  683. fd_set rset;
  684. struct timeval timeout;
  685. int dbits;
  687. slog(LOG_DEBUG, function);
  689. /*
  690.  * Find the socket we were signalled for.
  691.  */
  693. dbits = -1;
  694. FD_ZERO(&rset);
  696. for (i = 0, max = getdtablesize(); i < max; ++i) {
  697. if ((socksfd = socks_getaddr((unsigned int)i)) == NULL)
  698. continue;
  700. if (socksfd->state.command != SOCKS_BIND
  701. ||  socksfd->state.version != MSPROXY_V2
  702. || !socksfd->state.inprogress)
  703. continue;
  705. if (!socks_addrisok((unsigned int)i))
  706. continue;
  708. SASSERTX(fdisopen(socksfd->control));
  710. FD_SET(socksfd->control, &rset);
  711. dbits = MAX(dbits, socksfd->control);
  712. }
  714. if (dbits == -1) {
  715. if (oldsigio.sa_handler != NULL)
  716. oldsigio.sa_handler(sig);
  717. return; /* old signal handler. */
  718. }
  720. dset = 0;
  721. do {
  722. fd_set newrset;
  723. timeout.tv_sec = 0;
  724. timeout.tv_usec = 0;
  726. newrset = rset;
  727. switch (selectn(dbits + 1, &newrset, NULL, NULL, &timeout)) {
  728. case -1:
  729. SERR(-1);
  730. /* NOTREACHED */
  732. case 0:
  733. dset = 0;
  734. slog(LOG_DEBUG, "%s: no descriptors readable", function);
  735. if (oldsigio.sa_handler != NULL)
  736. oldsigio.sa_handler(sig);
  737. break;
  739. default: {
  740. dset = 1;
  741. for (i = 0, max = getdtablesize(); i < max; ++i) {
  742. if ((socksfd = socks_getaddr((unsigned int)i)) == NULL)
  743. continue;
  745. if (FD_ISSET(socksfd->control, &newrset)) {
  746. struct sockshost_t host;
  747. struct msproxy_request_t req;
  748. struct msproxy_response_t res;
  749. int p;
  751. SASSERTX(socksfd->state.command == SOCKS_BIND
  752. && socksfd->state.version == MSPROXY_V2
  753. && socksfd->state.inprogress);
  755. slog(LOG_DEBUG, "%s: attempting to receive bind info...",
  756. function);
  758. FD_CLR(socksfd->control, &newrset);
  760. if (recv_mspresponse(socksfd->control,
  761. &socksfd->state.msproxy, &res) == -1)
  762. continue;
  764. if (ntohs(res.command) != MSPROXY_BINDINFO) {
  765. swarnx("%s: expected res.command = %x, is 0x%x",
  766. function, MSPROXY_BINDINFO, ntohs(res.command));
  767. continue;
  768. }
  770. /* no need for more signals on this socket. */
  771. p = 0;
  772. if (ioctl(socksfd->control, FIOASYNC, &p) == -1) {
  773. swarn("%s: ioctl(socksfd->control)", function);
  774. continue;
  775. }
  777. slog(LOG_DEBUG, "%s: turned off sigio for %d",
  778. function, socksfd->control);
  780. /*
  781.  * if we asked server to bind INADDR_ANY, we don't know
  782.  * what address it bound until now.
  783.  */
  784. host.atype = SOCKS_ADDR_IPV4;
  785. host.port = res.packet._5.boundport;
  786. host.addr.ipv4.s_addr = res.packet._5.boundaddr;
  787. sockshost2sockaddr(&host, &socksfd->remote);
  789. slog(LOG_DEBUG, "%s: server bound address %s",
  790. function, sockshost2string(&host, NULL, 0));
  792. host.atype = SOCKS_ADDR_IPV4;
  793. host.port = res.packet._5.clientport;
  794. host.addr.ipv4.s_addr = res.packet._5.clientaddr;
  795. sockshost2sockaddr(&host, &socksfd->accepted);
  797. slog(LOG_DEBUG, "%s: server accepted: %s",
  798. function, sockshost2string(&host, NULL, 0));
  800. slog(LOG_DEBUG, "%s: server will connect to us from port %d",
  801. function, ntohs(res.packet._5.serverport));
  803. /* LINTED pointer casts may be troublesome */
  804. ((struct sockaddr_in *)&socksfd->reply)->sin_port
  805. = res.packet._5.serverport;
  807. slog(LOG_DEBUG, "%s: packet #6", function);
  809. bzero(&req, sizeof(req));
  810. req.clientid = socksfd->state.msproxy.clientid;
  811. req.serverid = socksfd->state.msproxy.serverid;
  812. req.command = htons(MSPROXY_BINDINFO_ACK);
  813. req.packet._6.magic1 = res.packet._5.magic1;
  814. req.packet._6.magic5 = htons(0x0100);
  815. req.packet._6.magic10 = socksfd->state.msproxy.bindid;
  816. req.packet._6.magic15 = htons(0x0100);
  817. req.packet._6.magic16 = socksfd->state.msproxy.bindid;
  818. req.packet._6.magic20 = htons(0x0200);
  819. req.packet._6.clientport = res.packet._5.clientport;
  820. req.packet._6.clientaddr = res.packet._5.clientaddr;
  821. req.packet._6.magic30 = res.packet._5.magic10;
  822. req.packet._6.magic35 = res.packet._5.magic15;
  823. req.packet._6.serverport = res.packet._5.serverport;
  824. req.packet._6.srcport = res.packet._5.srcport;
  825. req.packet._6.boundport = res.packet._5.boundport;
  826. req.packet._6.boundaddr = res.packet._5.boundaddr;
  828. if (send_msprequest(socksfd->control, &socksfd->state.msproxy,
  829. &req) == -1)
  830. continue;
  832. if (recv_mspresponse(socksfd->control,
  833. &socksfd->state.msproxy, &res) == -1)
  834. continue;
  836. /* all done.  Can accept(). */
  837. socksfd->state.inprogress = 0;
  838. }
  839. }
  840. }
  841. }
  842. } while (dset != 0);
  844. errno = errno_s;
  845. }
  848. int
  849. recv_mspresponse(s, state, response)
  850. int s;
  851. struct msproxy_state_t *state;
  852. struct msproxy_response_t *response;
  853. {
  854. const char *function = "recv_mspresponse()";
  855. /* CONSTCOND */
  856. char responsemem[MAX(sizeof(*response), 1024)];
  857. ssize_t r;
  859. /* CONSTCOND */
  860. while (1) {
  861. if ((r = read(s, responsemem, sizeof(responsemem))) < MSPROXY_MINLENGTH) {
  862. swarn("%s: expected to read atleast %d, read %d",
  863. function, MSPROXY_MINLENGTH, r);
  864. return -1;
  865. }
  867. if (mem2response(response, responsemem, (size_t)r) == NULL) {
  868. swarnx("%s: bad response from server", function);
  869. return -1;
  870. }
  872. if (state->seq_recv > 0) {
  873. if (response->sequence == state->seq_recv + 1)
  874. break; /* all ok. */
  875. else if (response->sequence < state->seq_recv) {
  876. /*
  877.  * sequence number less that last, sometimes this happens too,
  878.  * don't know why.
  879.  */
  880. slog(LOG_DEBUG, "%s: sequence (%d) < seq_recv (%d)",
  881. function, response->sequence, state->seq_recv);
  882. break;
  883. }
  884. else if (response->sequence == state->seq_recv) {
  885. slog(LOG_DEBUG, "%s: seq_recv: %d, dup response, seqnumber: 0x%x",
  886. function, state->seq_recv, response->sequence);
  888. if (response->clientack == state->seq_sent) {
  889. slog(LOG_DEBUG,
  890. "%s: ack matches last sent though, hoping it's a new one...",
  891. function);
  892. break;
  893. }
  894. }
  895. else if (response->sequence > state->seq_recv) {
  896. slog(LOG_DEBUG, "%s: sequence (%d) > seq_recv (%d)",
  897. function, response->sequence, state->seq_recv);
  898. break;
  899. }
  900. }
  901. else
  902. break; /* not started incrementing yet. */
  903. }
  905. state->seq_recv = response->sequence;
  907. return r;
  908. }
  911. int
  912. send_msprequest(s, state, request)
  913. int s;
  914. struct msproxy_state_t *state;
  915. struct msproxy_request_t *request;
  916. {
  917. const char *function = "send_msprequest()";
  918. ssize_t w;
  919. char requestmem[sizeof(struct msproxy_request_t)], *p;
  921. request->magic25 = htonl(MSPROXY_VERSION);
  922. request->serverack = state->seq_recv;
  923. /* don't start incrementing sequence until we are acking packet #2. */
  924. request->sequence
  925. = (unsigned char)(request->serverack >= 2 ? state->seq_sent + 1 : 0);
  927. memcpy(request->RWSP, "RWSP", sizeof(request->RWSP));
  929. p = request2mem(request, requestmem);
  931. /* all requests must be atleast MSPROXY_MINLENGTH it seems. */
  932. if (p - requestmem < MSPROXY_MINLENGTH) {
  933. bzero(p, (size_t)(MSPROXY_MINLENGTH - (p - requestmem)));
  934. p = requestmem + MSPROXY_MINLENGTH;
  935. }
  937. if ((w = write(s, requestmem, (size_t)(p - requestmem)))
  938. != (ssize_t)(p - requestmem)) {
  939. swarn("%s: write()", function);
  940. return -1;
  941. }
  942. state->seq_sent = request->sequence;
  944. return w;
  945. }
  947. static char *
  948. mem2response(res, mem, len)
  949. struct msproxy_response_t *res;
  950. char *mem;
  951. size_t len;
  952. {
  953. const char *function = "mem2response()";
  955. if (len < sizeof(res->packetid))
  956. return NULL;
  957. memcpy(&res->packetid, mem, sizeof(res->packetid));
  958. mem += sizeof(res->packetid);
  959. len -= sizeof(res->packetid);
  961. if (len < sizeof(res->magic5))
  962. return NULL;
  963. memcpy(&res->magic5, mem, sizeof(res->magic5));
  964. mem += sizeof(res->magic5);
  965. len -= sizeof(res->magic5);
  967. if (len < sizeof(res->serverid))
  968. return NULL;
  969. memcpy(&res->serverid, mem, sizeof(res->serverid));
  970. mem += sizeof(res->serverid);
  971. len -= sizeof(res->serverid);
  973. if (len < sizeof(res->clientack))
  974. return NULL;
  975. memcpy(&res->clientack, mem, sizeof(res->clientack));
  976. mem += sizeof(res->clientack);
  977. len -= sizeof(res->clientack);
  979. if (len < sizeof(res->pad5))
  980. return NULL;
  981. memcpy(res->pad5, mem, sizeof(res->pad5));
  982. mem += sizeof(res->pad5);
  983. len -= sizeof(res->pad5);
  985. if (len < sizeof(res->sequence))
  986. return NULL;
  987. memcpy(&res->sequence, mem, sizeof(res->sequence));
  988. mem += sizeof(res->sequence);
  989. len -= sizeof(res->sequence);
  991. if (len < sizeof(res->pad10))
  992. return NULL;
  993. memcpy(res->pad10, mem, sizeof(res->pad10));
  994. mem += sizeof(res->pad10);
  995. len -= sizeof(res->pad10);
  997. if (len < sizeof(res->RWSP))
  998. return NULL;
  999. memcpy(res->RWSP, mem, sizeof(res->RWSP));
  1000. mem += sizeof(res->RWSP);
  1001. len -= sizeof(res->RWSP);
  1003. if (len < sizeof(res->pad15))
  1004. return NULL;
  1005. memcpy(res->pad15, mem, sizeof(res->pad15));
  1006. mem += sizeof(res->pad15);
  1007. len -= sizeof(res->pad15);
  1009. if (len < sizeof(res->command))
  1010. return NULL;
  1011. memcpy(&res->command, mem, sizeof(res->command));
  1012. mem += sizeof(res->command);
  1013. len -= sizeof(res->command);
  1015. switch (ntohs(res->command)) {
  1016. case MSPROXY_HELLO_ACK:
  1017. if (len < sizeof(res->packet._1.pad5))
  1018. return NULL;
  1019. memcpy(res->packet._1.pad5, mem, sizeof(res->packet._1.pad5));
  1020. mem += sizeof(res->packet._1.pad5);
  1021. len -= sizeof(res->packet._1.pad5);
  1023. if (len < sizeof(res->packet._1.magic20))
  1024. return NULL;
  1025. memcpy(&res->packet._1.magic20, mem, sizeof(res->packet._1.magic20));
  1026. mem += sizeof(res->packet._1.magic20);
  1027. len -= sizeof(res->packet._1.magic20);
  1029. if (len < sizeof(res->packet._1.pad10))
  1030. return NULL;
  1031. memcpy(&res->packet._1.pad10, mem, sizeof(res->packet._1.pad10));
  1032. mem += sizeof(res->packet._1.pad10);
  1033. len -= sizeof(res->packet._1.pad10);
  1035. if (len < sizeof(res->packet._1.magic30))
  1036. return NULL;
  1037. memcpy(&res->packet._1.magic30, mem, sizeof(res->packet._1.magic30));
  1038. mem += sizeof(res->packet._1.magic30);
  1039. len -= sizeof(res->packet._1.magic30);
  1041. if (len < sizeof(res->packet._1.pad15))
  1042. return NULL;
  1043. memcpy(res->packet._1.pad15, mem, sizeof(res->packet._1.pad15));
  1044. mem += sizeof(res->packet._1.pad15);
  1045. len -= sizeof(res->packet._1.pad15);
  1047. if (len < sizeof(res->packet._1.magic35))
  1048. return NULL;
  1049. memcpy(&res->packet._1.magic35, mem, sizeof(res->packet._1.magic35));
  1050. mem += sizeof(res->packet._1.magic35);
  1051. len -= sizeof(res->packet._1.magic35);
  1053. if (len < sizeof(res->packet._1.pad20))
  1054. return NULL;
  1055. memcpy(res->packet._1.pad20, mem, sizeof(res->packet._1.pad20));
  1056. mem += sizeof(res->packet._1.pad20);
  1057. len -= sizeof(res->packet._1.pad20);
  1059. if (len < sizeof(res->packet._1.magic50))
  1060. return NULL;
  1061. memcpy(&res->packet._1.magic50, mem, sizeof(res->packet._1.magic50));
  1062. mem += sizeof(res->packet._1.magic50);
  1063. len -= sizeof(res->packet._1.magic50);
  1065. if (len < sizeof(res->packet._1.pad30))
  1066. return NULL;
  1067. memcpy(res->packet._1.pad30, mem, sizeof(res->packet._1.pad30));
  1068. mem += sizeof(res->packet._1.pad30);
  1069. len -= sizeof(res->packet._1.pad30);
  1071. if (len < sizeof(res->packet._1.magic60))
  1072. return NULL;
  1073. memcpy(&res->packet._1.magic60, mem, sizeof(res->packet._1.magic60));
  1074. mem += sizeof(res->packet._1.magic60);
  1075. len -= sizeof(res->packet._1.magic60);
  1077. if (len < sizeof(res->packet._1.pad35))
  1078. return NULL;
  1079. memcpy(res->packet._1.pad35, mem, sizeof(res->packet._1.pad35));
  1080. mem += sizeof(res->packet._1.pad35);
  1081. len -= sizeof(res->packet._1.pad35);
  1083. if (len < sizeof(res->packet._1.magic65))
  1084. return NULL;
  1085. memcpy(&res->packet._1.magic65, mem, sizeof(res->packet._1.magic65));
  1086. mem += sizeof(res->packet._1.magic65);
  1087. len -= sizeof(res->packet._1.magic65);
  1089. if (len < sizeof(res->packet._1.pad40))
  1090. return NULL;
  1091. memcpy(res->packet._1.pad40, mem, sizeof(res->packet._1.pad40));
  1092. mem += sizeof(res->packet._1.pad40);
  1093. len -= sizeof(res->packet._1.pad40);
  1095. if (len < sizeof(res->packet._1.udpport))
  1096. return NULL;
  1097. memcpy(&res->packet._1.udpport, mem, sizeof(res->packet._1.udpport));
  1098. mem += sizeof(res->packet._1.udpport);
  1099. len -= sizeof(res->packet._1.udpport);
  1101. if (len < sizeof(res->packet._1.udpaddr))
  1102. return NULL;
  1103. memcpy(&res->packet._1.udpaddr, mem, sizeof(res->packet._1.udpaddr));
  1104. mem += sizeof(res->packet._1.udpaddr);
  1105. len -= sizeof(res->packet._1.udpaddr);
  1107. break;
  1109. case MSPROXY_USERINFO_ACK:
  1110. if (len < sizeof(res->packet._2.pad5))
  1111. return NULL;
  1112. memcpy(res->packet._2.pad5, mem, sizeof(res->packet._2.pad5));
  1113. mem += sizeof(res->packet._2.pad5);
  1114. len -= sizeof(res->packet._2.pad5);
  1116. if (len < sizeof(res->packet._2.magic5))
  1117. return NULL;
  1118. memcpy(&res->packet._2.magic5, mem, sizeof(res->packet._2.magic5));
  1119. mem += sizeof(res->packet._2.magic5);
  1120. len -= sizeof(res->packet._2.magic5);
  1122. break;
  1124. case MSPROXY_BIND_ACK:
  1125. case MSPROXY_SOMETHING_1_ACK:
  1126. if (len < sizeof(res->packet._3.pad1))
  1127. return NULL;
  1128. memcpy(res->packet._3.pad1, mem, sizeof(res->packet._3.pad1));
  1129. mem += sizeof(res->packet._3.pad1);
  1130. len -= sizeof(res->packet._3.pad1);
  1132. if (len < sizeof(res->packet._3.magic10))
  1133. return NULL;
  1134. memcpy(&res->packet._3.magic10, mem, sizeof(res->packet._3.magic10));
  1135. mem += sizeof(res->packet._3.magic10);
  1136. len -= sizeof(res->packet._3.magic10);
  1138. if (len < sizeof(res->packet._3.pad3))
  1139. return NULL;
  1140. memcpy(res->packet._3.pad3, mem, sizeof(res->packet._3.pad3));
  1141. mem += sizeof(res->packet._3.pad3);
  1142. len -= sizeof(res->packet._3.pad3);
  1144. if (len < sizeof(res->packet._3.boundport))
  1145. return NULL;
  1146. memcpy(&res->packet._3.boundport, mem,
  1147. sizeof(res->packet._3.boundport));
  1148. mem += sizeof(res->packet._3.boundport);
  1149. len -= sizeof(res->packet._3.boundport);
  1151. if (len < sizeof(res->packet._3.boundaddr))
  1152. return NULL;
  1153. memcpy(&res->packet._3.boundaddr, mem,
  1154. sizeof(res->packet._3.boundaddr));
  1155. mem += sizeof(res->packet._3.boundaddr);
  1156. len -= sizeof(res->packet._3.boundaddr);
  1158. if (len < sizeof(res->packet._3.pad10))
  1159. return NULL;
  1160. memcpy(res->packet._3.pad10, mem, sizeof(res->packet._3.pad10));
  1161. mem += sizeof(res->packet._3.pad10);
  1162. len -= sizeof(res->packet._3.pad10);
  1164. if (len < sizeof(res->packet._3.magic15))
  1165. return NULL;
  1166. memcpy(&res->packet._3.magic15, mem, sizeof(res->packet._3.magic15));
  1167. mem += sizeof(res->packet._3.magic15);
  1168. len -= sizeof(res->packet._3.magic15);
  1170. if (len < sizeof(res->packet._3.pad15))
  1171. return NULL;
  1172. memcpy(res->packet._3.pad15, mem, sizeof(res->packet._3.pad15));
  1173. mem += sizeof(res->packet._3.pad15);
  1174. len -= sizeof(res->packet._3.pad15);
  1176. if (len < sizeof(res->packet._3.NTLMSSP))
  1177. return NULL;
  1178. memcpy(res->packet._3.NTLMSSP, mem, sizeof(res->packet._3.NTLMSSP));
  1179. mem += sizeof(res->packet._3.NTLMSSP);
  1180. len -= sizeof(res->packet._3.NTLMSSP);
  1182. if (len < sizeof(res->packet._3.magic50))
  1183. return NULL;
  1184. memcpy(&res->packet._3.magic50, mem, sizeof(res->packet._3.magic50));
  1185. mem += sizeof(res->packet._3.magic50);
  1186. len -= sizeof(res->packet._3.magic50);
  1188. if (len < sizeof(res->packet._3.pad50))
  1189. return NULL;
  1190. memcpy(res->packet._3.pad50, mem, sizeof(res->packet._3.pad50));
  1191. mem += sizeof(res->packet._3.pad50);
  1192. len -= sizeof(res->packet._3.pad50);
  1194. if (len < sizeof(res->packet._3.magic55))
  1195. return NULL;
  1196. memcpy(&res->packet._3.magic55, mem, sizeof(res->packet._3.magic55));
  1197. mem += sizeof(res->packet._3.magic55);
  1198. len -= sizeof(res->packet._3.magic55);
  1200. if (len < sizeof(res->packet._3.magic60))
  1201. return NULL;
  1202. memcpy(&res->packet._3.magic60, mem, sizeof(res->packet._3.magic60));
  1203. mem += sizeof(res->packet._3.magic60);
  1204. len -= sizeof(res->packet._3.magic60);
  1206. if (len < sizeof(res->packet._3.magic65))
  1207. return NULL;
  1208. memcpy(&res->packet._3.magic65, mem, sizeof(res->packet._3.magic65));
  1209. mem += sizeof(res->packet._3.magic65);
  1210. len -= sizeof(res->packet._3.magic65);
  1212. if (len < sizeof(res->packet._3.pad60))
  1213. return NULL;
  1214. memcpy(res->packet._3.pad60, mem, sizeof(res->packet._3.pad60));
  1215. mem += sizeof(res->packet._3.pad60);
  1216. len -= sizeof(res->packet._3.pad60);
  1218. if (len < sizeof(res->packet._3.magic70))
  1219. return NULL;
  1220. memcpy(&res->packet._3.magic70, mem, sizeof(res->packet._3.magic70));
  1221. mem += sizeof(res->packet._3.magic70);
  1222. len -= sizeof(res->packet._3.magic70);
  1224. if (len < sizeof(res->packet._3.magic75))
  1225. return NULL;
  1226. memcpy(&res->packet._3.magic75, mem, sizeof(res->packet._3.magic75));
  1227. mem += sizeof(res->packet._3.magic75);
  1228. len -= sizeof(res->packet._3.magic75);
  1230. if (len < sizeof(res->packet._3.pad70))
  1231. return NULL;
  1232. memcpy(res->packet._3.pad70, mem, sizeof(res->packet._3.pad70));
  1233. mem += sizeof(res->packet._3.pad70);
  1234. len -= sizeof(res->packet._3.pad70);
  1236. if (len > sizeof(res->packet._3.ntdomain))
  1237. swarnx("hmm, ntdomain length is %d, our max is %d?",
  1238. len, sizeof(res->packet._3.ntdomain) - 1);
  1239. memcpy(res->packet._3.ntdomain, mem,
  1240. MIN(len, sizeof(res->packet._3.ntdomain) - 1));
  1241. res->packet._3.ntdomain[len] = NUL;
  1242. mem += len;
  1243. len -= len;
  1245. break;
  1247. case MSPROXY_SOMETHING_2_ACK:
  1248. case MSPROXY_SOMETHING_2_ACK2:
  1249. case MSPROXY_BIND2_ACK:
  1250. if (len < sizeof(res->packet._4.pad5))
  1251. return NULL;
  1252. memcpy(res->packet._4.pad5, mem, sizeof(res->packet._4.pad5));
  1253. mem += sizeof(res->packet._4.pad5);
  1254. len -= sizeof(res->packet._4.pad5);
  1255. break;
  1257. case MSPROXY_RESOLVE_ACK: {
  1258. if (len < sizeof(res->packet.resolve.addroffset))
  1259. return NULL;
  1260. memcpy(&res->packet.resolve.addroffset, mem,
  1261. sizeof(res->packet.resolve.addroffset));
  1262. mem += sizeof(res->packet.resolve.addroffset);
  1263. len -= sizeof(res->packet.resolve.addroffset);
  1265. if (len < sizeof(res->packet.resolve.pad5))
  1266. return NULL;
  1267. memcpy(res->packet.resolve.pad5, mem,
  1268. sizeof(res->packet.resolve.pad5));
  1269. mem += sizeof(res->packet.resolve.pad5);
  1270. len -= sizeof(res->packet.resolve.pad5);
  1272. mem += res->packet.resolve.addroffset;
  1274. if (len < sizeof(res->packet.resolve.hostaddr))
  1275. return NULL;
  1276. memcpy(&res->packet.resolve.hostaddr, mem,
  1277. sizeof(res->packet.resolve.hostaddr));
  1278. mem += sizeof(res->packet.resolve.hostaddr);
  1279. len -= sizeof(res->packet.resolve.hostaddr);
  1281. break;
  1282. }
  1284. case MSPROXY_CONNECT_ACK:
  1285. case MSPROXY_BINDINFO:
  1286. if (len < sizeof(res->packet._5.magic1))
  1287. return NULL;
  1288. memcpy(&res->packet._5.magic1, mem, sizeof(res->packet._5.magic1));
  1289. mem += sizeof(res->packet._5.magic1);
  1290. len -= sizeof(res->packet._5.magic1);
  1292. if (len < sizeof(res->packet._5.pad5))
  1293. return NULL;
  1294. memcpy(res->packet._5.pad5, mem, sizeof(res->packet._5.pad5));
  1295. mem += sizeof(res->packet._5.pad5);
  1296. len -= sizeof(res->packet._5.pad5);
  1298. if (len < sizeof(res->packet._5.clientport))
  1299. return NULL;
  1300. memcpy(&res->packet._5.clientport, mem,
  1301. sizeof(res->packet._5.clientport));
  1302. mem += sizeof(res->packet._5.clientport);
  1303. len -= sizeof(res->packet._5.clientport);
  1305. if (len < sizeof(res->packet._5.clientaddr))
  1306. return NULL;
  1307. memcpy(&res->packet._5.clientaddr, mem,
  1308. sizeof(res->packet._5.clientaddr));
  1309. mem += sizeof(res->packet._5.clientaddr);
  1310. len -= sizeof(res->packet._5.clientaddr);
  1312. if (len < sizeof(res->packet._5.magic10))
  1313. return NULL;
  1314. memcpy(&res->packet._5.magic10, mem, sizeof(res->packet._5.magic10));
  1315. mem += sizeof(res->packet._5.magic10);
  1316. len -= sizeof(res->packet._5.magic10);
  1318. if (len < sizeof(res->packet._5.magic15))
  1319. return NULL;
  1320. memcpy(&res->packet._5.magic15, mem, sizeof(res->packet._5.magic15));
  1321. mem += sizeof(res->packet._5.magic15);
  1322. len -= sizeof(res->packet._5.magic15);
  1324. if (len < sizeof(res->packet._5.serverport))
  1325. return NULL;
  1326. memcpy(&res->packet._5.serverport, mem,
  1327. sizeof(res->packet._5.serverport));
  1328. mem += sizeof(res->packet._5.serverport);
  1329. len -= sizeof(res->packet._5.serverport);
  1331. if (len < sizeof(res->packet._5.srcport))
  1332. return NULL;
  1333. memcpy(&res->packet._5.srcport, mem, sizeof(res->packet._5.srcport));
  1334. mem += sizeof(res->packet._5.srcport);
  1335. len -= sizeof(res->packet._5.srcport);
  1337. if (len < sizeof(res->packet._5.boundport))
  1338. return NULL;
  1339. memcpy(&res->packet._5.boundport, mem,
  1340. sizeof(res->packet._5.boundport));
  1341. mem += sizeof(res->packet._5.boundport);
  1342. len -= sizeof(res->packet._5.boundport);
  1344. if (len < sizeof(res->packet._5.boundaddr))
  1345. return NULL;
  1346. memcpy(&res->packet._5.boundaddr, mem,
  1347. sizeof(res->packet._5.boundaddr));
  1348. mem += sizeof(res->packet._5.boundaddr);
  1349. len -= sizeof(res->packet._5.boundaddr);
  1351. if (len < sizeof(res->packet._5.pad10))
  1352. return NULL;
  1353. memcpy(res->packet._5.pad10, mem, sizeof(res->packet._5.pad10));
  1354. mem += sizeof(res->packet._5.pad10);
  1355. len -= sizeof(res->packet._5.pad10);
  1357. break;
  1359. case MSPROXY_CONNECT_AUTHFAILED:
  1360. case MSPROXY_BIND_AUTHFAILED:
  1361. break;
  1363. default:
  1364. if (ntohs(res->command) >> 8 == MSPROXY_CONNREFUSED
  1365. ||  ntohs(res->command) >> 12 == MSPROXY_CONNREFUSED)
  1366. ;
  1367. else
  1368. slog(LOG_DEBUG, "%s: unknown command in msproxy reply: 0x%x",
  1369. function, ntohs(res->command));
  1370. }
  1372. return mem;
  1373. }
  1375. static char *
  1376. request2mem(req, mem)
  1377. const struct msproxy_request_t *req;
  1378. char *mem;
  1379. {
  1381. memcpy(mem, &req->clientid, sizeof(req->clientid));
  1382. mem += sizeof(req->clientid);
  1384. memcpy(mem, &req->magic25, sizeof(req->magic25));
  1385. mem += sizeof(req->magic25);
  1387. memcpy(mem, &req->serverid, sizeof(req->serverid));
  1388. mem += sizeof(req->serverid);
  1390. memcpy(mem, &req->serverack, sizeof(req->serverack));
  1391. mem += sizeof(req->serverack);
  1393. memcpy(mem, &req->pad10, sizeof(req->pad10));
  1394. mem += sizeof(req->pad10);
  1396. memcpy(mem, &req->sequence, sizeof(req->sequence));
  1397. mem += sizeof(req->sequence);
  1399. memcpy(mem, &req->pad11, sizeof(req->pad11));
  1400. mem += sizeof(req->pad11);
  1402. memcpy(mem, &req->RWSP, sizeof(req->RWSP));
  1403. mem += sizeof(req->RWSP);
  1405. memcpy(mem, &req->pad15, sizeof(req->pad15));
  1406. mem += sizeof(req->pad15);
  1408. memcpy(mem, &req->command, sizeof(req->command));
  1409. mem += sizeof(req->command);
  1411. switch (ntohs(req->command)) {
  1412. case MSPROXY_HELLO:
  1413. memcpy(mem, &req->packet._1.pad1, sizeof(req->packet._1.pad1));
  1414. mem += sizeof(req->packet._1.pad1);
  1416. memcpy(mem, &req->packet._1.magic3, sizeof(req->packet._1.magic3));
  1417. mem += sizeof(req->packet._1.magic3);
  1419. memcpy(mem, &req->packet._1.pad3, sizeof(req->packet._1.pad3));
  1420. mem += sizeof(req->packet._1.pad3);
  1422. memcpy(mem, &req->packet._1.magic5, sizeof(req->packet._1.magic5));
  1423. mem += sizeof(req->packet._1.magic5);
  1425. memcpy(mem, &req->packet._1.pad5, sizeof(req->packet._1.pad5));
  1426. mem += sizeof(req->packet._1.pad5);
  1428. memcpy(mem, &req->packet._1.magic10, sizeof(req->packet._1.magic10));
  1429. mem += sizeof(req->packet._1.magic10);
  1431. memcpy(mem, &req->packet._1.pad6, sizeof(req->packet._1.pad6));
  1432. mem += sizeof(req->packet._1.pad6);
  1434. memcpy(mem, &req->packet._1.magic15, sizeof(req->packet._1.magic15));
  1435. mem += sizeof(req->packet._1.magic15);
  1437. memcpy(mem, &req->packet._1.pad10, sizeof(req->packet._1.pad10));
  1438. mem += sizeof(req->packet._1.pad10);
  1440. memcpy(mem, &req->packet._1.magic20, sizeof(req->packet._1.magic20));
  1441. mem += sizeof(req->packet._1.magic20);
  1443. memcpy(mem, &req->packet._1.magic25, sizeof(req->packet._1.magic25));
  1444. mem += sizeof(req->packet._1.magic25);
  1446. memcpy(mem, &req->packet._1.magic30, sizeof(req->packet._1.magic30));
  1447. mem += sizeof(req->packet._1.magic30);
  1449. memcpy(mem, &req->packet._1.pad20, sizeof(req->packet._1.pad20));
  1450. mem += sizeof(req->packet._1.pad20);
  1452. memcpy(mem, &req->packet._1.magic35, sizeof(req->packet._1.magic35));
  1453. mem += sizeof(req->packet._1.magic35);
  1455. memcpy(mem, &req->packet._1.pad30, sizeof(req->packet._1.pad30));
  1456. mem += sizeof(req->packet._1.pad30);
  1458. memcpy(mem, &req->packet._1.magic40, sizeof(req->packet._1.magic40));
  1459. mem += sizeof(req->packet._1.magic40);
  1461. memcpy(mem, &req->packet._1.pad40, sizeof(req->packet._1.pad40));
  1462. mem += sizeof(req->packet._1.pad40);
  1464. memcpy(mem, &req->packet._1.magic45, sizeof(req->packet._1.magic45));
  1465. mem += sizeof(req->packet._1.magic45);
  1467. memcpy(mem, &req->packet._1.pad45, sizeof(req->packet._1.pad45));
  1468. mem += sizeof(req->packet._1.pad45);
  1470. memcpy(mem, &req->packet._1.magic50, sizeof(req->packet._1.magic50));
  1471. mem += sizeof(req->packet._1.magic50);
  1473. memcpy(mem, &req->packet._1.pad50, sizeof(req->packet._1.pad50));
  1474. mem += sizeof(req->packet._1.pad50);
  1476. strcpy(mem, req->username);
  1477. mem += strlen(req->username) + 1;
  1479. strcpy(mem, req->unknown);
  1480. mem += strlen(req->unknown) + 1;
  1482. strcpy(mem, req->executable);
  1483. mem += strlen(req->executable) + 1;
  1485. strcpy(mem, req->clienthost);
  1486. mem += strlen(req->clienthost) + 1;
  1488. break;
  1490. case MSPROXY_USERINFO:
  1491. memcpy(mem, &req->packet._2.pad1, sizeof(req->packet._2.pad1));
  1492. mem += sizeof(req->packet._2.pad1);
  1494. memcpy(mem, &req->packet._2.magic3, sizeof(req->packet._2.magic3));
  1495. mem += sizeof(req->packet._2.magic3);
  1497. memcpy(mem, &req->packet._2.pad3, sizeof(req->packet._2.pad3));
  1498. mem += sizeof(req->packet._2.pad3);
  1500. memcpy(mem, &req->packet._2.magic5, sizeof(req->packet._2.magic5));
  1501. mem += sizeof(req->packet._2.magic5);
  1503. memcpy(mem, &req->packet._2.pad5, sizeof(req->packet._2.pad5));
  1504. mem += sizeof(req->packet._2.pad5);
  1506. memcpy(mem, &req->packet._2.magic10, sizeof(req->packet._2.magic10));
  1507. mem += sizeof(req->packet._2.magic10);
  1509. memcpy(mem, &req->packet._2.pad10, sizeof(req->packet._2.pad10));
  1510. mem += sizeof(req->packet._2.pad10);
  1512. memcpy(mem, &req->packet._2.magic15, sizeof(req->packet._2.magic15));
  1513. mem += sizeof(req->packet._2.magic15);
  1515. memcpy(mem, &req->packet._2.pad15, sizeof(req->packet._2.pad15));
  1516. mem += sizeof(req->packet._2.pad15);
  1518. memcpy(mem, &req->packet._2.magic20, sizeof(req->packet._2.magic20));
  1519. mem += sizeof(req->packet._2.magic20);
  1521. memcpy(mem, &req->packet._2.magic25, sizeof(req->packet._2.magic25));
  1522. mem += sizeof(req->packet._2.magic25);
  1524. memcpy(mem, &req->packet._2.magic30, sizeof(req->packet._2.magic30));
  1525. mem += sizeof(req->packet._2.magic30);
  1527. memcpy(mem, &req->packet._2.pad20, sizeof(req->packet._2.pad20));
  1528. mem += sizeof(req->packet._2.pad20);
  1530. memcpy(mem, &req->packet._2.magic35, sizeof(req->packet._2.magic35));
  1531. mem += sizeof(req->packet._2.magic35);
  1533. memcpy(mem, &req->packet._2.pad25, sizeof(req->packet._2.pad25));
  1534. mem += sizeof(req->packet._2.pad25);
  1536. memcpy(mem, &req->packet._2.magic35, sizeof(req->packet._2.magic35));
  1537. mem += sizeof(req->packet._2.magic35);
  1539. memcpy(mem, &req->packet._2.pad25, sizeof(req->packet._2.pad25));
  1540. mem += sizeof(req->packet._2.pad25);
  1542. memcpy(mem, &req->packet._2.magic50, sizeof(req->packet._2.magic50));
  1543. mem += sizeof(req->packet._2.magic50);
  1545. memcpy(mem, &req->packet._2.pad50, sizeof(req->packet._2.pad50));
  1546. mem += sizeof(req->packet._2.pad50);
  1548. memcpy(mem, &req->packet._2.magic55, sizeof(req->packet._2.magic55));
  1549. mem += sizeof(req->packet._2.magic55);
  1551. memcpy(mem, &req->packet._2.pad55, sizeof(req->packet._2.pad55));
  1552. mem += sizeof(req->packet._2.pad55);
  1554. memcpy(mem, &req->packet._2.magic60, sizeof(req->packet._2.magic60));
  1555. mem += sizeof(req->packet._2.magic60);
  1557. strcpy(mem, req->username);
  1558. mem += strlen(req->username) + 1;
  1560. strcpy(mem, req->unknown);
  1561. mem += strlen(req->unknown) + 1;
  1563. strcpy(mem, req->executable);
  1564. mem += strlen(req->executable) + 1;
  1566. strcpy(mem, req->clienthost);
  1567. mem += strlen(req->clienthost) + 1;
  1569. break;
  1571. case MSPROXY_BIND:
  1572. case MSPROXY_SOMETHING:
  1573. memcpy(mem, &req->packet._3.pad1, sizeof(req->packet._3.pad1));
  1574. mem += sizeof(req->packet._3.pad1);
  1576. memcpy(mem, &req->packet._3.magic2, sizeof(req->packet._3.magic2));
  1577. mem += sizeof(req->packet._3.magic2);
  1579. memcpy(mem, &req->packet._3.pad10, sizeof(req->packet._3.pad10));
  1580. mem += sizeof(req->packet._3.pad10);
  1582. memcpy(mem, &req->packet._3.bindaddr, sizeof(req->packet._3.bindaddr));
  1583. mem += sizeof(req->packet._3.bindaddr);
  1585. memcpy(mem, &req->packet._3.bindport, sizeof(req->packet._3.bindport));
  1586. mem += sizeof(req->packet._3.bindport);
  1588. memcpy(mem, &req->packet._3.pad15, sizeof(req->packet._3.pad15));
  1589. mem += sizeof(req->packet._3.pad15);
  1591. memcpy(mem, &req->packet._3.magic3, sizeof(req->packet._3.magic3));
  1592. mem += sizeof(req->packet._3.magic3);
  1594. memcpy(mem, &req->packet._3.boundport,
  1595. sizeof(req->packet._3.boundport));
  1596. mem += sizeof(req->packet._3.boundport);
  1598. memcpy(mem, &req->packet._3.pad20, sizeof(req->packet._3.pad20));
  1599. mem += sizeof(req->packet._3.pad20);
  1601. memcpy(mem, &req->packet._3.NTLMSSP, sizeof(req->packet._3.NTLMSSP));
  1602. mem += sizeof(req->packet._3.NTLMSSP);
  1604. memcpy(mem, &req->packet._3.magic5, sizeof(req->packet._3.magic5));
  1605. mem += sizeof(req->packet._3.magic5);
  1607. memcpy(mem, &req->packet._3.pad25, sizeof(req->packet._3.pad25));
  1608. mem += sizeof(req->packet._3.pad25);
  1610. memcpy(mem, &req->packet._3.magic10, sizeof(req->packet._3.magic10));
  1611. mem += sizeof(req->packet._3.magic10);
  1613. memcpy(mem, &req->packet._3.magic15, sizeof(req->packet._3.magic15));
  1614. mem += sizeof(req->packet._3.magic15);
  1616. memcpy(mem, &req->packet._3.magic20, sizeof(req->packet._3.magic20));
  1617. mem += sizeof(req->packet._3.magic20);
  1619. memcpy(mem, &req->packet._3.pad30, sizeof(req->packet._3.pad30));
  1620. mem += sizeof(req->packet._3.pad30);
  1622. memcpy(mem, &req->packet._3.magic25, sizeof(req->packet._3.magic25));
  1623. mem += sizeof(req->packet._3.magic25);
  1625. memcpy(mem, &req->packet._3.magic30, sizeof(req->packet._3.magic30));
  1626. mem += sizeof(req->packet._3.magic30);
  1628. memcpy(mem, &req->packet._3.pad40, sizeof(req->packet._3.pad40));
  1629. mem += sizeof(req->packet._3.pad40);
  1631. memcpy(mem, &req->packet._3.magic50, sizeof(req->packet._3.magic50));
  1632. mem += sizeof(req->packet._3.magic50);
  1634. memcpy(mem, &req->packet._3.pad50, sizeof(req->packet._3.pad50));
  1635. mem += sizeof(req->packet._3.pad50);
  1637. memcpy(mem, &req->packet._3.magic55, sizeof(req->packet._3.magic55));
  1638. mem += sizeof(req->packet._3.magic55);
  1640. memcpy(mem, &req->packet._3.pad55, sizeof(req->packet._3.pad55));
  1641. mem += sizeof(req->packet._3.pad55);
  1643. break;
  1645. case MSPROXY_BIND2:
  1646. case MSPROXY_SOMETHING_2:
  1647. memcpy(mem, &req->packet._4.pad1, sizeof(req->packet._4.pad1));
  1648. mem += sizeof(req->packet._4.pad1);
  1650. memcpy(mem, &req->packet._4.magic1, sizeof(req->packet._4.magic1));
  1651. mem += sizeof(req->packet._4.magic1);
  1653. memcpy(mem, &req->packet._4.magic2, sizeof(req->packet._4.magic2));
  1654. mem += sizeof(req->packet._4.magic2);
  1656. memcpy(mem, &req->packet._4.pad2, sizeof(req->packet._4.pad2));
  1657. mem += sizeof(req->packet._4.pad2);
  1659. memcpy(mem, &req->packet._4.magic3, sizeof(req->packet._4.magic3));
  1660. mem += sizeof(req->packet._4.magic3);
  1662. memcpy(mem, &req->packet._4.pad3, sizeof(req->packet._4.pad3));
  1663. mem += sizeof(req->packet._4.pad3);
  1665. memcpy(mem, &req->packet._4.magic4, sizeof(req->packet._4.magic4));
  1666. mem += sizeof(req->packet._4.magic4);
  1668. memcpy(mem, &req->packet._4.boundport,
  1669. sizeof(req->packet._4.boundport));
  1670. mem += sizeof(req->packet._4.boundport);
  1672. memcpy(mem, &req->packet._4.pad4, sizeof(req->packet._4.pad4));
  1673. mem += sizeof(req->packet._4.pad4);
  1675. memcpy(mem, &req->packet._4.NTLMSSP, sizeof(req->packet._4.NTLMSSP));
  1676. mem += sizeof(req->packet._4.NTLMSSP);
  1678. memcpy(mem, &req->packet._4.magic5, sizeof(req->packet._4.magic5));
  1679. mem += sizeof(req->packet._4.magic5);
  1681. memcpy(mem, &req->packet._4.pad5, sizeof(req->packet._4.pad5));
  1682. mem += sizeof(req->packet._4.pad5);
  1684. memcpy(mem, &req->packet._4.magic10, sizeof(req->packet._4.magic10));
  1685. mem += sizeof(req->packet._4.magic10);
  1687. memcpy(mem, &req->packet._4.magic10, sizeof(req->packet._4.magic10));
  1688. mem += sizeof(req->packet._4.magic10);
  1690. memcpy(mem, &req->packet._4.magic20, sizeof(req->packet._4.magic20));
  1691. mem += sizeof(req->packet._4.magic20);
  1693. memcpy(mem, &req->packet._4.pad10, sizeof(req->packet._4.pad10));
  1694. mem += sizeof(req->packet._4.pad10);
  1696. memcpy(mem, &req->packet._4.magic30, sizeof(req->packet._4.magic30));
  1697. mem += sizeof(req->packet._4.magic30);
  1699. memcpy(mem, &req->packet._4.pad15, sizeof(req->packet._4.pad15));
  1700. mem += sizeof(req->packet._4.pad15);
  1702. memcpy(mem, &req->packet._4.magic35, sizeof(req->packet._4.magic35));
  1703. mem += sizeof(req->packet._4.magic35);
  1705. memcpy(mem, &req->packet._4.magic40, sizeof(req->packet._4.magic40));
  1706. mem += sizeof(req->packet._4.magic40);
  1708. memcpy(mem, &req->packet._4.magic45, sizeof(req->packet._4.magic45));
  1709. mem += sizeof(req->packet._4.magic45);
  1711. memcpy(mem, &req->packet._4.pad20, sizeof(req->packet._4.pad20));
  1712. mem += sizeof(req->packet._4.pad20);
  1714. memcpy(mem, &req->packet._4.magic50, sizeof(req->packet._4.magic50));
  1715. mem += sizeof(req->packet._4.magic50);
  1717. memcpy(mem, &req->packet._4.magic55, sizeof(req->packet._4.magic55));
  1718. mem += sizeof(req->packet._4.magic55);
  1720. memcpy(mem, &req->packet._4.magic60, sizeof(req->packet._4.magic60));
  1721. mem += sizeof(req->packet._4.magic60);
  1723. memcpy(mem, &req->packet._4.pad25, sizeof(req->packet._4.pad25));
  1724. mem += sizeof(req->packet._4.pad25);
  1726. memcpy(mem, &req->packet._4.magic65, sizeof(req->packet._4.magic65));
  1727. mem += sizeof(req->packet._4.magic65);
  1729. memcpy(mem, &req->packet._4.magic70, sizeof(req->packet._4.magic70));
  1730. mem += sizeof(req->packet._4.magic70);
  1732. memcpy(mem, &req->packet._4.magic75, sizeof(req->packet._4.magic75));
  1733. mem += sizeof(req->packet._4.magic75);
  1735. break;
  1737. case MSPROXY_RESOLVE:
  1738. memcpy(mem, &req->packet.resolve.hostlength,
  1739. sizeof(req->packet.resolve.hostlength));
  1740. mem += sizeof(req->packet.resolve.hostlength);
  1742. memcpy(mem, &req->packet.resolve.pad1,
  1743. sizeof(req->packet.resolve.pad1));
  1744. mem += sizeof(req->packet.resolve.pad1);
  1746. memcpy(mem, &req->packet.resolve.host,
  1747. (size_t)req->packet.resolve.hostlength);
  1748. mem += req->packet.resolve.hostlength;
  1750. break;
  1752. case MSPROXY_LISTEN:
  1753. case MSPROXY_CONNECT:
  1754. memcpy(mem, &req->packet._5.magic1, sizeof(req->packet._5.magic1));
  1755. mem += sizeof(req->packet._5.magic1);
  1757. memcpy(mem, &req->packet._5.pad1, sizeof(req->packet._5.pad1));
  1758. mem += sizeof(req->packet._5.pad1);
  1760. memcpy(mem, &req->packet._5.magic3, sizeof(req->packet._5.magic3));
  1761. mem += sizeof(req->packet._5.magic3);
  1763. memcpy(mem, &req->packet._5.pad5, sizeof(req->packet._5.pad5));
  1764. mem += sizeof(req->packet._5.pad5);
  1766. memcpy(mem, &req->packet._5.magic6, sizeof(req->packet._5.magic6));
  1767. mem += sizeof(req->packet._5.magic6);
  1769. memcpy(mem, &req->packet._5.destport, sizeof(req->packet._5.destport));
  1770. mem += sizeof(req->packet._5.destport);
  1772. memcpy(mem, &req->packet._5.destaddr, sizeof(req->packet._5.destaddr));
  1773. mem += sizeof(req->packet._5.destaddr);
  1775. memcpy(mem, &req->packet._5.pad10, sizeof(req->packet._5.pad10));
  1776. mem += sizeof(req->packet._5.pad10);
  1778. memcpy(mem, &req->packet._5.magic10, sizeof(req->packet._5.magic10));
  1779. mem += sizeof(req->packet._5.magic10);
  1781. memcpy(mem, &req->packet._5.pad15, sizeof(req->packet._5.pad15));
  1782. mem += sizeof(req->packet._5.pad15);
  1784. memcpy(mem, &req->packet._5.srcport, sizeof(req->packet._5.srcport));
  1785. mem += sizeof(req->packet._5.srcport);
  1787. memcpy(mem, &req->packet._5.pad20, sizeof(req->packet._5.pad20));
  1788. mem += sizeof(req->packet._5.pad20);
  1789. strcpy(mem, req->executable);
  1791. break;
  1793. case MSPROXY_BINDINFO_ACK:
  1794. case MSPROXY_CONNECTED:
  1795. memcpy(mem, &req->packet._6.magic1, sizeof(req->packet._6.magic1));
  1796. mem += sizeof(req->packet._6.magic1);
  1798. memcpy(mem, req->packet._6.pad5, sizeof(req->packet._6.pad5));
  1799. mem += sizeof(req->packet._6.pad5);
  1801. memcpy(mem, &req->packet._6.magic5, sizeof(req->packet._6.magic5));
  1802. mem += sizeof(req->packet._6.magic5);
  1804. memcpy(mem, &req->packet._6.magic10, sizeof(req->packet._6.magic10));
  1805. mem += sizeof(req->packet._6.magic10);
  1807. memcpy(mem, req->packet._6.pad10, sizeof(req->packet._6.pad10));
  1808. mem += sizeof(req->packet._6.pad10);
  1810. memcpy(mem, &req->packet._6.magic15, sizeof(req->packet._6.magic15));
  1811. mem += sizeof(req->packet._6.magic15);
  1813. memcpy(mem, &req->packet._6.magic16, sizeof(req->packet._6.magic16));
  1814. mem += sizeof(req->packet._6.magic16);
  1816. memcpy(mem, &req->packet._6.magic20, sizeof(req->packet._6.magic20));
  1817. mem += sizeof(req->packet._6.magic20);
  1819. memcpy(mem, &req->packet._6.clientport,
  1820. sizeof(req->packet._6.clientport));
  1821. mem += sizeof(req->packet._6.clientport);
  1823. memcpy(mem, &req->packet._6.clientaddr,
  1824. sizeof(req->packet._6.clientaddr));
  1825. mem += sizeof(req->packet._6.clientaddr);
  1827. memcpy(mem, &req->packet._6.magic30, sizeof(req->packet._6.magic30));
  1828. mem += sizeof(req->packet._6.magic30);
  1830. memcpy(mem, &req->packet._6.magic35, sizeof(req->packet._6.magic35));
  1831. mem += sizeof(req->packet._6.magic35);
  1833. memcpy(mem, &req->packet._6.serverport,
  1834. sizeof(req->packet._6.serverport));
  1835. mem += sizeof(req->packet._6.serverport);
  1837. memcpy(mem, &req->packet._6.srcport, sizeof(req->packet._6.srcport));
  1838. mem += sizeof(req->packet._6.srcport);
  1840. memcpy(mem, &req->packet._6.boundport,
  1841. sizeof(req->packet._6.boundport));
  1842. mem += sizeof(req->packet._6.boundport);
  1844. memcpy(mem, &req->packet._6.boundaddr,
  1845. sizeof(req->packet._6.boundaddr));
  1846. mem += sizeof(req->packet._6.boundaddr);
  1848. memcpy(mem, req->packet._6.pad30, sizeof(req->packet._6.pad30));
  1849. mem += sizeof(req->packet._6.pad30);
  1851. break;
  1853. case MSPROXY_SESSIONEND:
  1854. break;
  1856. default:
  1857. SERRX(req->command);
  1858. }
  1860. return mem;
  1861. }
  1863. void
  1864. msproxy_sessionsend(void)
  1865. {
  1866. const char *function = "msproxy_sessionsend()";
  1867. int i, max;
  1868. struct socksfd_t *socksfd;
  1870. slog(LOG_DEBUG, function);
  1872. for (i = 0, max = getdtablesize(); i < max; ++i) {
  1873. if ((socksfd = socks_getaddr((unsigned int)i)) == NULL)
  1874. continue;
  1876. if (socksfd->state.version != MSPROXY_V2)
  1877. continue;
  1879. msproxy_sessionend(socksfd->control, &socksfd->state.msproxy);
  1880. }
  1881. }
  1883. static void
  1884. msproxy_sessionend(s, msproxy)
  1885. int s;
  1886. struct msproxy_state_t *msproxy;
  1887. {
  1888. const char *function = "msproxy_sessionend()";
  1889. struct msproxy_request_t req;
  1891. slog(LOG_DEBUG, function);
  1893. bzero(&req, sizeof(req));
  1894. *req.username = NUL;
  1895. *req.unknown = NUL;
  1896. *req.executable = NUL;
  1897. *req.clienthost = NUL;
  1898. req.clientid = msproxy->clientid;
  1899. req.serverid = msproxy->serverid;
  1900. req.command = htons(MSPROXY_SESSIONEND);
  1902. send_msprequest(s, msproxy, &req);
  1903. }
  1905. /* ARGSUSED */
  1906. static void
  1907. msproxy_keepalive(sig)
  1908. int sig;
  1909. {
  1910. const char *function = "msproxy_keepalive()";
  1911. struct msproxy_request_t req;
  1912. struct msproxy_response_t res;
  1913. struct socksfd_t *socksfd;
  1914. int i, max;
  1916. slog(LOG_DEBUG, function);
  1918. for (i = 0, max = getdtablesize(); i < max; ++i) {
  1919. if ((socksfd = socks_getaddr((unsigned int)i)) == NULL)
  1920. continue;
  1922. if (socksfd->state.version != MSPROXY_V2
  1923. ||  socksfd->state.inprogress)
  1924. continue;
  1926. slog(LOG_DEBUG, "%s: sending keepalive packet", function);
  1928. bzero(&req, sizeof(req));
  1929. req.clientid = socksfd->state.msproxy.clientid;
  1930. req.serverid = socksfd->state.msproxy.serverid;
  1931. req.command = htons(MSPROXY_HELLO);
  1933. if (send_msprequest(socksfd->control, &socksfd->state.msproxy, &req)
  1934. == -1)
  1935. return;
  1937. if (recv_mspresponse(socksfd->control, &socksfd->state.msproxy, &res)
  1938. == -1)
  1939. return;
  1940. }
  1941. }