| 1 |
/************************************************************************ |
| 2 |
* network.c Low-level networking routines * |
| 3 |
* Copyright (C) 1998-2022 Ben Webb * |
| 4 |
* Email: [email protected] * |
| 5 |
* WWW: https://dopewars.sourceforge.io/ * |
| 6 |
* * |
| 7 |
* This program is free software; you can redistribute it and/or * |
| 8 |
* modify it under the terms of the GNU General Public License * |
| 9 |
* as published by the Free Software Foundation; either version 2 * |
| 10 |
* of the License, or (at your option) any later version. * |
| 11 |
* * |
| 12 |
* This program is distributed in the hope that it will be useful, * |
| 13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of * |
| 14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * |
| 15 |
* GNU General Public License for more details. * |
| 16 |
* * |
| 17 |
* You should have received a copy of the GNU General Public License * |
| 18 |
* along with this program; if not, write to the Free Software * |
| 19 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, * |
| 20 |
* MA 02111-1307, USA. * |
| 21 |
************************************************************************/ |
| 22 |
|
| 23 |
#ifdef HAVE_CONFIG_H |
| 24 |
#include <config.h> |
| 25 |
#endif |
| 26 |
|
| 27 |
#ifdef NETWORKING |
| 28 |
|
| 29 |
#ifdef CYGWIN |
| 30 |
#include <winsock2.h> /* For network functions */ |
| 31 |
#include <windows.h> /* For datatypes such as BOOL */ |
| 32 |
#include "winmain.h" |
| 33 |
#else |
| 34 |
#include <sys/types.h> /* For size_t etc. */ |
| 35 |
#include <sys/socket.h> /* For struct sockaddr etc. */ |
| 36 |
#include <netinet/in.h> /* For struct sockaddr_in etc. */ |
| 37 |
#include <arpa/inet.h> /* For socklen_t */ |
| 38 |
#include <pwd.h> /* For getpwuid */ |
| 39 |
#include <string.h> /* For memcpy, strlen etc. */ |
| 40 |
#ifdef HAVE_UNISTD_H |
| 41 |
#include <unistd.h> /* For close(), various types and |
| 42 |
* constants */ |
| 43 |
#endif |
| 44 |
#ifdef HAVE_FCNTL_H |
| 45 |
#include <fcntl.h> /* For fcntl() */ |
| 46 |
#endif |
| 47 |
#include <netdb.h> /* For gethostbyname() */ |
| 48 |
#endif /* CYGWIN */ |
| 49 |
|
| 50 |
#include <glib.h> |
| 51 |
#include <errno.h> /* For errno and Unix error codes */ |
| 52 |
#include <stdlib.h> /* For exit() and atoi() */ |
| 53 |
#include <stdio.h> /* For perror() */ |
| 54 |
|
| 55 |
#include "error.h" |
| 56 |
#include "network.h" |
| 57 |
#include "nls.h" |
| 58 |
|
| 59 |
/* Maximum sizes (in bytes) of read and write buffers - connections should |
| 60 |
* be dropped if either buffer is filled */ |
| 61 |
#define MAXREADBUF (32768) |
| 62 |
#define MAXWRITEBUF (65536) |
| 63 |
|
| 64 |
/* SOCKS5 authentication method codes */ |
| 65 |
typedef enum { |
| 66 |
SM_NOAUTH = 0, /* No authentication required */ |
| 67 |
SM_GSSAPI = 1, /* GSSAPI */ |
| 68 |
SM_USERPASSWD = 2 /* Username/password authentication */ |
| 69 |
} SocksMethods; |
| 70 |
|
| 71 |
static gboolean StartSocksNegotiation(NetworkBuffer *NetBuf, |
| 72 |
gchar *RemoteHost, |
| 73 |
unsigned RemotePort); |
| 74 |
static gboolean StartConnect(int *fd, const gchar *bindaddr, gchar *RemoteHost, |
| 75 |
unsigned RemotePort, gboolean *doneOK, |
| 76 |
LastError **error); |
| 77 |
|
| 78 |
#ifdef CYGWIN |
| 79 |
|
| 80 |
void StartNetworking() |
| 81 |
{ |
| 82 |
WSADATA wsaData; |
| 83 |
LastError *error; |
| 84 |
GString *errstr; |
| 85 |
|
| 86 |
if (WSAStartup(MAKEWORD(1, 0), &wsaData) != 0) { |
| 87 |
error = NewError(ET_WINSOCK, WSAGetLastError(), NULL); |
| 88 |
errstr = g_string_new(""); |
| 89 |
g_string_assign_error(errstr, error); |
| 90 |
g_log(NULL, G_LOG_LEVEL_CRITICAL, _("Cannot initialize WinSock (%s)!"), |
| 91 |
errstr->str); |
| 92 |
g_string_free(errstr, TRUE); |
| 93 |
FreeError(error); |
| 94 |
exit(EXIT_FAILURE); |
| 95 |
} |
| 96 |
} |
| 97 |
|
| 98 |
void StopNetworking() |
| 99 |
{ |
| 100 |
WSACleanup(); |
| 101 |
} |
| 102 |
|
| 103 |
void SetReuse(SOCKET sock) |
| 104 |
{ |
| 105 |
BOOL i = TRUE; |
| 106 |
|
| 107 |
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&i, |
| 108 |
sizeof(i)) == -1) { |
| 109 |
perror("setsockopt"); |
| 110 |
exit(EXIT_FAILURE); |
| 111 |
} |
| 112 |
} |
| 113 |
|
| 114 |
void SetBlocking(SOCKET sock, gboolean blocking) |
| 115 |
{ |
| 116 |
unsigned long param; |
| 117 |
|
| 118 |
param = blocking ? 0 : 1; |
| 119 |
ioctlsocket(sock, FIONBIO, ¶m); |
| 120 |
} |
| 121 |
|
| 122 |
#else |
| 123 |
|
| 124 |
void StartNetworking() |
| 125 |
{ |
| 126 |
} |
| 127 |
|
| 128 |
void StopNetworking() |
| 129 |
{ |
| 130 |
} |
| 131 |
|
| 132 |
void SetReuse(int sock) |
| 133 |
{ |
| 134 |
int i = 1; |
| 135 |
|
| 136 |
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)) == -1) { |
| 137 |
perror("setsockopt"); |
| 138 |
exit(EXIT_FAILURE); |
| 139 |
} |
| 140 |
} |
| 141 |
|
| 142 |
void SetBlocking(int sock, gboolean blocking) |
| 143 |
{ |
| 144 |
fcntl(sock, F_SETFL, blocking ? 0 : O_NONBLOCK); |
| 145 |
} |
| 146 |
|
| 147 |
#endif /* CYGWIN */ |
| 148 |
|
| 149 |
static gboolean FinishConnect(int fd, LastError **error); |
| 150 |
|
| 151 |
static void NetBufCallBack(NetworkBuffer *NetBuf, gboolean CallNow) |
| 152 |
{ |
| 153 |
if (NetBuf && NetBuf->CallBack) { |
| 154 |
(*NetBuf->CallBack) (NetBuf, NetBuf->status != NBS_PRECONNECT, |
| 155 |
(NetBuf->status == NBS_CONNECTED |
| 156 |
&& NetBuf->WriteBuf.DataPresent) |
| 157 |
|| (NetBuf->status == NBS_SOCKSCONNECT |
| 158 |
&& NetBuf->negbuf.DataPresent) |
| 159 |
|| NetBuf->WaitConnect, TRUE, CallNow); |
| 160 |
} |
| 161 |
} |
| 162 |
|
| 163 |
static void NetBufCallBackStop(NetworkBuffer *NetBuf) |
| 164 |
{ |
| 165 |
if (NetBuf && NetBuf->CallBack) { |
| 166 |
(*NetBuf->CallBack) (NetBuf, FALSE, FALSE, FALSE, FALSE); |
| 167 |
} |
| 168 |
} |
| 169 |
|
| 170 |
static void InitConnBuf(ConnBuf *buf) |
| 171 |
{ |
| 172 |
buf->Data = NULL; |
| 173 |
buf->Length = 0; |
| 174 |
buf->DataPresent = 0; |
| 175 |
} |
| 176 |
|
| 177 |
static void FreeConnBuf(ConnBuf *buf) |
| 178 |
{ |
| 179 |
g_free(buf->Data); |
| 180 |
InitConnBuf(buf); |
| 181 |
} |
| 182 |
|
| 183 |
/* |
| 184 |
* Initializes the passed network buffer, ready for use. Messages sent |
| 185 |
* or received on the buffered connection will be terminated by the |
| 186 |
* given character, and if they end in "StripChar" it will be removed |
| 187 |
* before the messages are sent or received. |
| 188 |
*/ |
| 189 |
void InitNetworkBuffer(NetworkBuffer *NetBuf, char Terminator, |
| 190 |
char StripChar, SocksServer *socks) |
| 191 |
{ |
| 192 |
NetBuf->fd = -1; |
| 193 |
NetBuf->ioch = NULL; |
| 194 |
NetBuf->InputTag = 0; |
| 195 |
NetBuf->CallBack = NULL; |
| 196 |
NetBuf->CallBackData = NULL; |
| 197 |
NetBuf->Terminator = Terminator; |
| 198 |
NetBuf->StripChar = StripChar; |
| 199 |
InitConnBuf(&NetBuf->ReadBuf); |
| 200 |
InitConnBuf(&NetBuf->WriteBuf); |
| 201 |
InitConnBuf(&NetBuf->negbuf); |
| 202 |
NetBuf->WaitConnect = FALSE; |
| 203 |
NetBuf->status = NBS_PRECONNECT; |
| 204 |
NetBuf->socks = socks; |
| 205 |
NetBuf->host = NULL; |
| 206 |
NetBuf->userpasswd = NULL; |
| 207 |
NetBuf->error = NULL; |
| 208 |
} |
| 209 |
|
| 210 |
void SetNetworkBufferCallBack(NetworkBuffer *NetBuf, NBCallBack CallBack, |
| 211 |
gpointer CallBackData) |
| 212 |
{ |
| 213 |
NetBufCallBackStop(NetBuf); |
| 214 |
NetBuf->CallBack = CallBack; |
| 215 |
NetBuf->CallBackData = CallBackData; |
| 216 |
NetBufCallBack(NetBuf, FALSE); |
| 217 |
} |
| 218 |
|
| 219 |
/* |
| 220 |
* Sets the function used to obtain a username and password for SOCKS5 |
| 221 |
* username/password authentication. |
| 222 |
*/ |
| 223 |
void SetNetworkBufferUserPasswdFunc(NetworkBuffer *NetBuf, |
| 224 |
NBUserPasswd userpasswd, gpointer data) |
| 225 |
{ |
| 226 |
NetBuf->userpasswd = userpasswd; |
| 227 |
NetBuf->userpasswddata = data; |
| 228 |
} |
| 229 |
|
| 230 |
/* |
| 231 |
* Sets up the given network buffer to handle data being sent/received |
| 232 |
* through the given socket. |
| 233 |
*/ |
| 234 |
void BindNetworkBufferToSocket(NetworkBuffer *NetBuf, int fd) |
| 235 |
{ |
| 236 |
NetBuf->fd = fd; |
| 237 |
#ifdef CYGIN |
| 238 |
NetBuf->ioch = g_io_channel_win32_new_socket(fd); |
| 239 |
#else |
| 240 |
NetBuf->ioch = g_io_channel_unix_new(fd); |
| 241 |
#endif |
| 242 |
|
| 243 |
SetBlocking(fd, FALSE); /* We only deal with non-blocking sockets */ |
| 244 |
NetBuf->status = NBS_CONNECTED; /* Assume the socket is connected */ |
| 245 |
} |
| 246 |
|
| 247 |
/* |
| 248 |
* Returns TRUE if the pointer is to a valid network buffer, and it's |
| 249 |
* connected to an active socket. |
| 250 |
*/ |
| 251 |
gboolean IsNetworkBufferActive(NetworkBuffer *NetBuf) |
| 252 |
{ |
| 253 |
return (NetBuf && NetBuf->fd >= 0); |
| 254 |
} |
| 255 |
|
| 256 |
gboolean StartNetworkBufferConnect(NetworkBuffer *NetBuf, |
| 257 |
const gchar *bindaddr, |
| 258 |
gchar *RemoteHost, unsigned RemotePort) |
| 259 |
{ |
| 260 |
gchar *realhost; |
| 261 |
unsigned realport; |
| 262 |
gboolean doneOK; |
| 263 |
|
| 264 |
ShutdownNetworkBuffer(NetBuf); |
| 265 |
|
| 266 |
if (NetBuf->socks) { |
| 267 |
realhost = NetBuf->socks->name; |
| 268 |
realport = NetBuf->socks->port; |
| 269 |
} else { |
| 270 |
realhost = RemoteHost; |
| 271 |
realport = RemotePort; |
| 272 |
} |
| 273 |
|
| 274 |
if (StartConnect(&NetBuf->fd, bindaddr, realhost, realport, &doneOK, |
| 275 |
&NetBuf->error)) { |
| 276 |
#ifdef CYGIN |
| 277 |
NetBuf->ioch = g_io_channel_win32_new_socket(NetBuf->fd); |
| 278 |
#else |
| 279 |
NetBuf->ioch = g_io_channel_unix_new(NetBuf->fd); |
| 280 |
#endif |
| 281 |
/* If we connected immediately, then set status, otherwise signal that |
| 282 |
* we're waiting for the connect to complete */ |
| 283 |
if (doneOK) { |
| 284 |
NetBuf->status = NetBuf->socks ? NBS_SOCKSCONNECT : NBS_CONNECTED; |
| 285 |
NetBuf->sockstat = NBSS_METHODS; |
| 286 |
} else { |
| 287 |
NetBuf->WaitConnect = TRUE; |
| 288 |
} |
| 289 |
|
| 290 |
if (NetBuf->socks |
| 291 |
&& !StartSocksNegotiation(NetBuf, RemoteHost, RemotePort)) { |
| 292 |
return FALSE; |
| 293 |
} |
| 294 |
|
| 295 |
/* Notify the owner if necessary to check for the connection |
| 296 |
* completing and/or for data to be writeable */ |
| 297 |
NetBufCallBack(NetBuf, FALSE); |
| 298 |
|
| 299 |
return TRUE; |
| 300 |
} else { |
| 301 |
return FALSE; |
| 302 |
} |
| 303 |
} |
| 304 |
|
| 305 |
/* |
| 306 |
* Frees the network buffer's data structures (leaving it in the |
| 307 |
* 'initialized' state) and closes the accompanying socket. |
| 308 |
*/ |
| 309 |
void ShutdownNetworkBuffer(NetworkBuffer *NetBuf) |
| 310 |
{ |
| 311 |
NetBufCallBackStop(NetBuf); |
| 312 |
|
| 313 |
if (NetBuf->fd >= 0) { |
| 314 |
CloseSocket(NetBuf->fd); |
| 315 |
g_io_channel_unref(NetBuf->ioch); |
| 316 |
NetBuf->fd = -1; |
| 317 |
} |
| 318 |
|
| 319 |
FreeConnBuf(&NetBuf->ReadBuf); |
| 320 |
FreeConnBuf(&NetBuf->WriteBuf); |
| 321 |
FreeConnBuf(&NetBuf->negbuf); |
| 322 |
|
| 323 |
FreeError(NetBuf->error); |
| 324 |
NetBuf->error = NULL; |
| 325 |
|
| 326 |
g_free(NetBuf->host); |
| 327 |
|
| 328 |
InitNetworkBuffer(NetBuf, NetBuf->Terminator, NetBuf->StripChar, |
| 329 |
NetBuf->socks); |
| 330 |
} |
| 331 |
|
| 332 |
/* |
| 333 |
* Updates the sets of read and write file descriptors to monitor |
| 334 |
* input to/output from the given network buffer. MaxSock is updated |
| 335 |
* with the highest-numbered file descriptor (plus 1) for use in a |
| 336 |
* later select() call. |
| 337 |
*/ |
| 338 |
void SetSelectForNetworkBuffer(NetworkBuffer *NetBuf, fd_set *readfds, |
| 339 |
fd_set *writefds, fd_set *errorfds, |
| 340 |
int *MaxSock) |
| 341 |
{ |
| 342 |
if (!NetBuf || NetBuf->fd <= 0) |
| 343 |
return; |
| 344 |
FD_SET(NetBuf->fd, readfds); |
| 345 |
if (errorfds) |
| 346 |
FD_SET(NetBuf->fd, errorfds); |
| 347 |
if (NetBuf->fd >= *MaxSock) |
| 348 |
*MaxSock = NetBuf->fd + 1; |
| 349 |
if ((NetBuf->status == NBS_CONNECTED && NetBuf->WriteBuf.DataPresent) |
| 350 |
|| (NetBuf->status == NBS_SOCKSCONNECT && NetBuf->negbuf.DataPresent) |
| 351 |
|| NetBuf->WaitConnect) { |
| 352 |
FD_SET(NetBuf->fd, writefds); |
| 353 |
} |
| 354 |
} |
| 355 |
|
| 356 |
typedef enum { |
| 357 |
SEC_5FAILURE = 1, |
| 358 |
SEC_5RULESET = 2, |
| 359 |
SEC_5NETDOWN = 3, |
| 360 |
SEC_5UNREACH = 4, |
| 361 |
SEC_5CONNREF = 5, |
| 362 |
SEC_5TTLEXPIRED = 6, |
| 363 |
SEC_5COMMNOSUPP = 7, |
| 364 |
SEC_5ADDRNOSUPP = 8, |
| 365 |
|
| 366 |
SEC_REJECT = 91, |
| 367 |
SEC_NOIDENTD = 92, |
| 368 |
SEC_IDMISMATCH = 93, |
| 369 |
|
| 370 |
SEC_UNKNOWN = 200, |
| 371 |
SEC_AUTHFAILED, |
| 372 |
SEC_USERCANCEL, |
| 373 |
SEC_ADDRTYPE, |
| 374 |
SEC_REPLYVERSION, |
| 375 |
SEC_VERSION, |
| 376 |
SEC_NOMETHODS |
| 377 |
} SocksErrorCode; |
| 378 |
|
| 379 |
static ErrTable SocksErrStr[] = { |
| 380 |
/* SOCKS version 5 error messages */ |
| 381 |
{SEC_5FAILURE, N_("SOCKS server general failure")}, |
| 382 |
{SEC_5RULESET, N_("Connection denied by SOCKS ruleset")}, |
| 383 |
{SEC_5NETDOWN, N_("SOCKS: Network unreachable")}, |
| 384 |
{SEC_5UNREACH, N_("SOCKS: Host unreachable")}, |
| 385 |
{SEC_5CONNREF, N_("SOCKS: Connection refused")}, |
| 386 |
{SEC_5TTLEXPIRED, N_("SOCKS: TTL expired")}, |
| 387 |
{SEC_5COMMNOSUPP, N_("SOCKS: Command not supported")}, |
| 388 |
{SEC_5ADDRNOSUPP, N_("SOCKS: Address type not supported")}, |
| 389 |
{SEC_NOMETHODS, N_("SOCKS server rejected all offered methods")}, |
| 390 |
{SEC_ADDRTYPE, N_("Unknown SOCKS address type returned")}, |
| 391 |
{SEC_AUTHFAILED, N_("SOCKS authentication failed")}, |
| 392 |
{SEC_USERCANCEL, N_("SOCKS authentication canceled by user")}, |
| 393 |
|
| 394 |
/* SOCKS version 4 error messages */ |
| 395 |
{SEC_REJECT, N_("SOCKS: Request rejected or failed")}, |
| 396 |
{SEC_NOIDENTD, N_("SOCKS: Rejected - unable to contact identd")}, |
| 397 |
{SEC_IDMISMATCH, |
| 398 |
N_("SOCKS: Rejected - identd reports different user-id")}, |
| 399 |
|
| 400 |
/* SOCKS errors due to protocol violations */ |
| 401 |
{SEC_UNKNOWN, N_("Unknown SOCKS reply code")}, |
| 402 |
{SEC_REPLYVERSION, N_("Unknown SOCKS reply version code")}, |
| 403 |
{SEC_VERSION, N_("Unknown SOCKS server version")}, |
| 404 |
{0, NULL} |
| 405 |
}; |
| 406 |
|
| 407 |
static void SocksAppendError(GString *str, LastError *error) |
| 408 |
{ |
| 409 |
LookupErrorCode(str, error->code, SocksErrStr, _("SOCKS error code %d")); |
| 410 |
} |
| 411 |
|
| 412 |
static ErrorType ETSocks = { SocksAppendError, NULL }; |
| 413 |
|
| 414 |
static gboolean Socks5UserPasswd(NetworkBuffer *NetBuf) |
| 415 |
{ |
| 416 |
if (!NetBuf->userpasswd) { |
| 417 |
SetError(&NetBuf->error, &ETSocks, SEC_NOMETHODS, NULL); |
| 418 |
return FALSE; |
| 419 |
} else { |
| 420 |
/* Request a username and password (the callback function should in |
| 421 |
* turn call SendSocks5UserPasswd when it's done) */ |
| 422 |
NetBuf->sockstat = NBSS_USERPASSWD; |
| 423 |
(*NetBuf->userpasswd) (NetBuf, NetBuf->userpasswddata); |
| 424 |
return TRUE; |
| 425 |
} |
| 426 |
} |
| 427 |
|
| 428 |
void SendSocks5UserPasswd(NetworkBuffer *NetBuf, gchar *user, |
| 429 |
gchar *password) |
| 430 |
{ |
| 431 |
gchar *addpt; |
| 432 |
guint addlen; |
| 433 |
ConnBuf *conn; |
| 434 |
|
| 435 |
if (!user || !password || !user[0] || !password[0]) { |
| 436 |
SetError(&NetBuf->error, &ETSocks, SEC_USERCANCEL, NULL); |
| 437 |
NetBufCallBack(NetBuf, TRUE); |
| 438 |
return; |
| 439 |
} |
| 440 |
conn = &NetBuf->negbuf; |
| 441 |
addlen = 3 + strlen(user) + strlen(password); |
| 442 |
addpt = ExpandWriteBuffer(conn, addlen, &NetBuf->error); |
| 443 |
if (!addpt || strlen(user) > 255 || strlen(password) > 255) { |
| 444 |
SetError(&NetBuf->error, ET_CUSTOM, E_FULLBUF, NULL); |
| 445 |
NetBufCallBack(NetBuf, TRUE); |
| 446 |
return; |
| 447 |
} |
| 448 |
addpt[0] = 1; /* Subnegotiation version code */ |
| 449 |
addpt[1] = strlen(user); |
| 450 |
strcpy(&addpt[2], user); |
| 451 |
addpt[2 + strlen(user)] = strlen(password); |
| 452 |
strcpy(&addpt[3 + strlen(user)], password); |
| 453 |
|
| 454 |
CommitWriteBuffer(NetBuf, conn, addpt, addlen); |
| 455 |
} |
| 456 |
|
| 457 |
static gboolean Socks5Connect(NetworkBuffer *NetBuf) |
| 458 |
{ |
| 459 |
gchar *addpt; |
| 460 |
guint addlen, hostlen; |
| 461 |
ConnBuf *conn; |
| 462 |
unsigned short int netport; |
| 463 |
|
| 464 |
conn = &NetBuf->negbuf; |
| 465 |
g_assert(NetBuf->host); |
| 466 |
hostlen = strlen(NetBuf->host); |
| 467 |
if (hostlen > 255) |
| 468 |
return FALSE; |
| 469 |
|
| 470 |
netport = htons(NetBuf->port); |
| 471 |
g_assert(sizeof(netport) == 2); |
| 472 |
|
| 473 |
addlen = hostlen + 7; |
| 474 |
addpt = ExpandWriteBuffer(conn, addlen, &NetBuf->error); |
| 475 |
if (!addpt) |
| 476 |
return FALSE; |
| 477 |
addpt[0] = 5; /* SOCKS version 5 */ |
| 478 |
addpt[1] = 1; /* CONNECT */ |
| 479 |
addpt[2] = 0; /* reserved - must be zero */ |
| 480 |
addpt[3] = 3; /* Address type - FQDN */ |
| 481 |
addpt[4] = hostlen; /* Length of address */ |
| 482 |
strcpy(&addpt[5], NetBuf->host); |
| 483 |
memcpy(&addpt[5 + hostlen], &netport, sizeof(netport)); |
| 484 |
|
| 485 |
NetBuf->sockstat = NBSS_CONNECT; |
| 486 |
|
| 487 |
CommitWriteBuffer(NetBuf, conn, addpt, addlen); |
| 488 |
|
| 489 |
return TRUE; |
| 490 |
} |
| 491 |
|
| 492 |
static gboolean HandleSocksReply(NetworkBuffer *NetBuf) |
| 493 |
{ |
| 494 |
gchar *data; |
| 495 |
guchar addrtype; |
| 496 |
guint replylen; |
| 497 |
gboolean retval = TRUE; |
| 498 |
|
| 499 |
if (NetBuf->socks->version == 5) { |
| 500 |
if (NetBuf->sockstat == NBSS_METHODS) { |
| 501 |
data = GetWaitingData(NetBuf, 2); |
| 502 |
if (data) { |
| 503 |
retval = FALSE; |
| 504 |
if (data[0] != 5) { |
| 505 |
SetError(&NetBuf->error, &ETSocks, SEC_VERSION, NULL); |
| 506 |
} else if (data[1] == SM_NOAUTH) { |
| 507 |
retval = Socks5Connect(NetBuf); |
| 508 |
} else if (data[1] == SM_USERPASSWD) { |
| 509 |
retval = Socks5UserPasswd(NetBuf); |
| 510 |
} else { |
| 511 |
SetError(&NetBuf->error, &ETSocks, SEC_NOMETHODS, NULL); |
| 512 |
} |
| 513 |
g_free(data); |
| 514 |
} |
| 515 |
} else if (NetBuf->sockstat == NBSS_USERPASSWD) { |
| 516 |
data = GetWaitingData(NetBuf, 2); |
| 517 |
if (data) { |
| 518 |
retval = FALSE; |
| 519 |
if (data[1] != 0) { |
| 520 |
SetError(&NetBuf->error, &ETSocks, SEC_AUTHFAILED, NULL); |
| 521 |
} else { |
| 522 |
retval = Socks5Connect(NetBuf); |
| 523 |
} |
| 524 |
g_free(data); |
| 525 |
} |
| 526 |
} else if (NetBuf->sockstat == NBSS_CONNECT) { |
| 527 |
data = PeekWaitingData(NetBuf, 5); |
| 528 |
if (data) { |
| 529 |
retval = FALSE; |
| 530 |
addrtype = data[3]; |
| 531 |
if (data[0] != 5) { |
| 532 |
SetError(&NetBuf->error, &ETSocks, SEC_VERSION, NULL); |
| 533 |
} else if (data[1] > 8) { |
| 534 |
SetError(&NetBuf->error, &ETSocks, SEC_UNKNOWN, NULL); |
| 535 |
} else if (data[1] != 0) { |
| 536 |
SetError(&NetBuf->error, &ETSocks, data[1], NULL); |
| 537 |
} else if (addrtype != 1 && addrtype != 3 && addrtype != 4) { |
| 538 |
SetError(&NetBuf->error, &ETSocks, SEC_ADDRTYPE, NULL); |
| 539 |
} else { |
| 540 |
retval = TRUE; |
| 541 |
replylen = 6; |
| 542 |
if (addrtype == 1) |
| 543 |
replylen += 4; /* IPv4 address */ |
| 544 |
else if (addrtype == 4) |
| 545 |
replylen += 16; /* IPv6 address */ |
| 546 |
else |
| 547 |
replylen += data[4]; /* FQDN */ |
| 548 |
data = GetWaitingData(NetBuf, replylen); |
| 549 |
if (data) { |
| 550 |
NetBuf->status = NBS_CONNECTED; |
| 551 |
g_free(data); |
| 552 |
NetBufCallBack(NetBuf, FALSE); /* status has changed */ |
| 553 |
} |
| 554 |
} |
| 555 |
} |
| 556 |
} |
| 557 |
return retval; |
| 558 |
} else { |
| 559 |
data = GetWaitingData(NetBuf, 8); |
| 560 |
if (data) { |
| 561 |
retval = FALSE; |
| 562 |
if (data[0] != 0) { |
| 563 |
SetError(&NetBuf->error, &ETSocks, SEC_REPLYVERSION, NULL); |
| 564 |
} else { |
| 565 |
if (data[1] == 90) { |
| 566 |
NetBuf->status = NBS_CONNECTED; |
| 567 |
NetBufCallBack(NetBuf, FALSE); /* status has changed */ |
| 568 |
retval = TRUE; |
| 569 |
} else if (data[1] >= SEC_REJECT && data[1] <= SEC_IDMISMATCH) { |
| 570 |
SetError(&NetBuf->error, &ETSocks, data[1], NULL); |
| 571 |
} else { |
| 572 |
SetError(&NetBuf->error, &ETSocks, SEC_UNKNOWN, NULL); |
| 573 |
} |
| 574 |
} |
| 575 |
g_free(data); |
| 576 |
} |
| 577 |
return retval; |
| 578 |
} |
| 579 |
} |
| 580 |
|
| 581 |
/* |
| 582 |
* Reads and writes data if the network connection is ready. Sets the |
| 583 |
* various OK variables to TRUE if no errors occurred in the relevant |
| 584 |
* operations, and returns TRUE if data was read and is waiting for |
| 585 |
* processing. |
| 586 |
*/ |
| 587 |
static gboolean DoNetworkBufferStuff(NetworkBuffer *NetBuf, |
| 588 |
gboolean ReadReady, |
| 589 |
gboolean WriteReady, |
| 590 |
gboolean ErrorReady, gboolean *ReadOK, |
| 591 |
gboolean *WriteOK, gboolean *ErrorOK) |
| 592 |
{ |
| 593 |
gboolean DataWaiting = FALSE, ConnectDone = FALSE; |
| 594 |
gboolean retval; |
| 595 |
|
| 596 |
*ReadOK = *WriteOK = *ErrorOK = TRUE; |
| 597 |
|
| 598 |
if (ErrorReady || NetBuf->error) |
| 599 |
*ErrorOK = FALSE; |
| 600 |
else if (NetBuf->WaitConnect) { |
| 601 |
if (WriteReady) { |
| 602 |
retval = FinishConnect(NetBuf->fd, &NetBuf->error); |
| 603 |
ConnectDone = TRUE; |
| 604 |
NetBuf->WaitConnect = FALSE; |
| 605 |
|
| 606 |
if (retval) { |
| 607 |
if (NetBuf->socks) { |
| 608 |
NetBuf->status = NBS_SOCKSCONNECT; |
| 609 |
NetBuf->sockstat = NBSS_METHODS; |
| 610 |
} else { |
| 611 |
NetBuf->status = NBS_CONNECTED; |
| 612 |
} |
| 613 |
} else { |
| 614 |
NetBuf->status = NBS_PRECONNECT; |
| 615 |
*WriteOK = FALSE; |
| 616 |
} |
| 617 |
} |
| 618 |
} else { |
| 619 |
if (WriteReady) |
| 620 |
*WriteOK = WriteDataToWire(NetBuf); |
| 621 |
|
| 622 |
if (ReadReady) { |
| 623 |
*ReadOK = ReadDataFromWire(NetBuf); |
| 624 |
if (NetBuf->ReadBuf.DataPresent > 0 && |
| 625 |
NetBuf->status == NBS_SOCKSCONNECT) { |
| 626 |
if (!HandleSocksReply(NetBuf) |
| 627 |
|| NetBuf->error) { /* From SendSocks5UserPasswd, possibly */ |
| 628 |
*ErrorOK = FALSE; |
| 629 |
} |
| 630 |
} |
| 631 |
if (NetBuf->ReadBuf.DataPresent > 0 && |
| 632 |
NetBuf->status != NBS_SOCKSCONNECT) { |
| 633 |
DataWaiting = TRUE; |
| 634 |
} |
| 635 |
} |
| 636 |
} |
| 637 |
|
| 638 |
if (!(*ErrorOK && *WriteOK && *ReadOK)) { |
| 639 |
/* We don't want to check the socket any more */ |
| 640 |
NetBufCallBackStop(NetBuf); |
| 641 |
/* If there were errors, then the socket is now useless - so close it */ |
| 642 |
CloseSocket(NetBuf->fd); |
| 643 |
NetBuf->fd = -1; |
| 644 |
} else if (ConnectDone) { |
| 645 |
/* If we just connected, then no need to listen for write-ready status |
| 646 |
* any more */ |
| 647 |
NetBufCallBack(NetBuf, FALSE); |
| 648 |
} else if (WriteReady |
| 649 |
&& ((NetBuf->status == NBS_CONNECTED |
| 650 |
&& NetBuf->WriteBuf.DataPresent == 0) |
| 651 |
|| (NetBuf->status == NBS_SOCKSCONNECT |
| 652 |
&& NetBuf->negbuf.DataPresent == 0))) { |
| 653 |
/* If we wrote out everything, then tell the owner so that the socket |
| 654 |
* no longer needs to be checked for write-ready status */ |
| 655 |
NetBufCallBack(NetBuf, FALSE); |
| 656 |
} |
| 657 |
|
| 658 |
return DataWaiting; |
| 659 |
} |
| 660 |
|
| 661 |
/* |
| 662 |
* Responds to a select() call by reading/writing data as necessary. |
| 663 |
* If any data were read, TRUE is returned. "DoneOK" is set TRUE |
| 664 |
* unless a fatal error (i.e. the connection was broken) occurred. |
| 665 |
*/ |
| 666 |
gboolean RespondToSelect(NetworkBuffer *NetBuf, fd_set *readfds, |
| 667 |
fd_set *writefds, fd_set *errorfds, |
| 668 |
gboolean *DoneOK) |
| 669 |
{ |
| 670 |
gboolean ReadOK, WriteOK, ErrorOK; |
| 671 |
gboolean DataWaiting = FALSE; |
| 672 |
|
| 673 |
*DoneOK = TRUE; |
| 674 |
if (!NetBuf || NetBuf->fd <= 0) |
| 675 |
return DataWaiting; |
| 676 |
DataWaiting = DoNetworkBufferStuff(NetBuf, FD_ISSET(NetBuf->fd, readfds), |
| 677 |
FD_ISSET(NetBuf->fd, writefds), |
| 678 |
errorfds ? FD_ISSET(NetBuf->fd, |
| 679 |
errorfds) : FALSE, |
| 680 |
&ReadOK, &WriteOK, &ErrorOK); |
| 681 |
*DoneOK = (WriteOK && ErrorOK && ReadOK); |
| 682 |
return DataWaiting; |
| 683 |
} |
| 684 |
|
| 685 |
gboolean NetBufHandleNetwork(NetworkBuffer *NetBuf, gboolean ReadReady, |
| 686 |
gboolean WriteReady, gboolean ErrorReady, |
| 687 |
gboolean *DoneOK) |
| 688 |
{ |
| 689 |
gboolean ReadOK, WriteOK, ErrorOK; |
| 690 |
gboolean DataWaiting = FALSE; |
| 691 |
|
| 692 |
*DoneOK = TRUE; |
| 693 |
if (!NetBuf || NetBuf->fd <= 0) |
| 694 |
return DataWaiting; |
| 695 |
|
| 696 |
DataWaiting = DoNetworkBufferStuff(NetBuf, ReadReady, WriteReady, ErrorReady, |
| 697 |
&ReadOK, &WriteOK, &ErrorOK); |
| 698 |
|
| 699 |
*DoneOK = (WriteOK && ErrorOK && ReadOK); |
| 700 |
return DataWaiting; |
| 701 |
} |
| 702 |
|
| 703 |
/* |
| 704 |
* Returns the number of complete (terminated) messages waiting in the |
| 705 |
* given network buffer. This is the number of times that |
| 706 |
* GetWaitingMessage() can be safely called without it returning NULL. |
| 707 |
*/ |
| 708 |
gint CountWaitingMessages(NetworkBuffer *NetBuf) |
| 709 |
{ |
| 710 |
ConnBuf *conn; |
| 711 |
gint i, msgs = 0; |
| 712 |
|
| 713 |
if (NetBuf->status != NBS_CONNECTED) |
| 714 |
return 0; |
| 715 |
|
| 716 |
conn = &NetBuf->ReadBuf; |
| 717 |
|
| 718 |
if (conn->Data) |
| 719 |
for (i = 0; i < conn->DataPresent; i++) { |
| 720 |
if (conn->Data[i] == NetBuf->Terminator) |
| 721 |
msgs++; |
| 722 |
} |
| 723 |
return msgs; |
| 724 |
} |
| 725 |
|
| 726 |
gchar *PeekWaitingData(NetworkBuffer *NetBuf, int numbytes) |
| 727 |
{ |
| 728 |
ConnBuf *conn; |
| 729 |
|
| 730 |
conn = &NetBuf->ReadBuf; |
| 731 |
if (!conn->Data || conn->DataPresent < numbytes) |
| 732 |
return NULL; |
| 733 |
else |
| 734 |
return conn->Data; |
| 735 |
} |
| 736 |
|
| 737 |
gchar *GetWaitingData(NetworkBuffer *NetBuf, int numbytes) |
| 738 |
{ |
| 739 |
ConnBuf *conn; |
| 740 |
gchar *data; |
| 741 |
|
| 742 |
conn = &NetBuf->ReadBuf; |
| 743 |
if (!conn->Data || conn->DataPresent < numbytes) |
| 744 |
return NULL; |
| 745 |
|
| 746 |
data = g_new(gchar, numbytes); |
| 747 |
memcpy(data, conn->Data, numbytes); |
| 748 |
|
| 749 |
memmove(&conn->Data[0], &conn->Data[numbytes], |
| 750 |
conn->DataPresent - numbytes); |
| 751 |
conn->DataPresent -= numbytes; |
| 752 |
|
| 753 |
return data; |
| 754 |
} |
| 755 |
|
| 756 |
/* |
| 757 |
* Reads a complete (terminated) message from the network buffer. The |
| 758 |
* message is removed from the buffer, and returned as a null-terminated |
| 759 |
* string (the network terminator is removed). If no complete message is |
| 760 |
* waiting, NULL is returned. The string is dynamically allocated, and |
| 761 |
* so must be g_free'd by the caller. |
| 762 |
*/ |
| 763 |
gchar *GetWaitingMessage(NetworkBuffer *NetBuf) |
| 764 |
{ |
| 765 |
ConnBuf *conn; |
| 766 |
int MessageLen; |
| 767 |
char *SepPt; |
| 768 |
gchar *NewMessage; |
| 769 |
|
| 770 |
conn = &NetBuf->ReadBuf; |
| 771 |
if (!conn->Data || !conn->DataPresent || NetBuf->status != NBS_CONNECTED) { |
| 772 |
return NULL; |
| 773 |
} |
| 774 |
SepPt = memchr(conn->Data, NetBuf->Terminator, conn->DataPresent); |
| 775 |
if (!SepPt) |
| 776 |
return NULL; |
| 777 |
*SepPt = '\0'; |
| 778 |
MessageLen = SepPt - conn->Data + 1; |
| 779 |
SepPt--; |
| 780 |
if (NetBuf->StripChar && *SepPt == NetBuf->StripChar) |
| 781 |
*SepPt = '\0'; |
| 782 |
NewMessage = g_new(gchar, MessageLen); |
| 783 |
|
| 784 |
memcpy(NewMessage, conn->Data, MessageLen); |
| 785 |
if (MessageLen < conn->DataPresent) { |
| 786 |
memmove(&conn->Data[0], &conn->Data[MessageLen], |
| 787 |
conn->DataPresent - MessageLen); |
| 788 |
} |
| 789 |
conn->DataPresent -= MessageLen; |
| 790 |
return NewMessage; |
| 791 |
} |
| 792 |
|
| 793 |
/* |
| 794 |
* Reads any waiting data on the given network buffer's TCP/IP connection |
| 795 |
* into the read buffer. Returns FALSE if the connection was closed, or |
| 796 |
* if the read buffer's maximum size was reached. |
| 797 |
*/ |
| 798 |
gboolean ReadDataFromWire(NetworkBuffer *NetBuf) |
| 799 |
{ |
| 800 |
ConnBuf *conn; |
| 801 |
int CurrentPosition, BytesRead; |
| 802 |
|
| 803 |
conn = &NetBuf->ReadBuf; |
| 804 |
CurrentPosition = conn->DataPresent; |
| 805 |
while (1) { |
| 806 |
if (CurrentPosition >= conn->Length) { |
| 807 |
if (conn->Length == MAXREADBUF) { |
| 808 |
SetError(&NetBuf->error, ET_CUSTOM, E_FULLBUF, NULL); |
| 809 |
return FALSE; /* drop connection */ |
| 810 |
} |
| 811 |
if (conn->Length == 0) |
| 812 |
conn->Length = 256; |
| 813 |
else |
| 814 |
conn->Length *= 2; |
| 815 |
if (conn->Length > MAXREADBUF) |
| 816 |
conn->Length = MAXREADBUF; |
| 817 |
conn->Data = g_realloc(conn->Data, conn->Length); |
| 818 |
} |
| 819 |
BytesRead = recv(NetBuf->fd, &conn->Data[CurrentPosition], |
| 820 |
conn->Length - CurrentPosition, 0); |
| 821 |
if (BytesRead == SOCKET_ERROR) { |
| 822 |
#ifdef CYGWIN |
| 823 |
int Error = WSAGetLastError(); |
| 824 |
|
| 825 |
if (Error == WSAEWOULDBLOCK) |
| 826 |
break; |
| 827 |
else { |
| 828 |
SetError(&NetBuf->error, ET_WINSOCK, Error, NULL); |
| 829 |
return FALSE; |
| 830 |
} |
| 831 |
#else |
| 832 |
if (errno == EAGAIN) |
| 833 |
break; |
| 834 |
else if (errno != EINTR) { |
| 835 |
SetError(&NetBuf->error, ET_ERRNO, errno, NULL); |
| 836 |
return FALSE; |
| 837 |
} |
| 838 |
#endif |
| 839 |
} else if (BytesRead == 0) { |
| 840 |
return FALSE; |
| 841 |
} else { |
| 842 |
CurrentPosition += BytesRead; |
| 843 |
conn->DataPresent = CurrentPosition; |
| 844 |
} |
| 845 |
} |
| 846 |
return TRUE; |
| 847 |
} |
| 848 |
|
| 849 |
gchar *ExpandWriteBuffer(ConnBuf *conn, int numbytes, LastError **error) |
| 850 |
{ |
| 851 |
int newlen; |
| 852 |
|
| 853 |
newlen = conn->DataPresent + numbytes; |
| 854 |
if (newlen > conn->Length) { |
| 855 |
conn->Length *= 2; |
| 856 |
conn->Length = MAX(conn->Length, newlen); |
| 857 |
if (conn->Length > MAXWRITEBUF) |
| 858 |
conn->Length = MAXWRITEBUF; |
| 859 |
if (newlen > conn->Length) { |
| 860 |
if (error) |
| 861 |
SetError(error, ET_CUSTOM, E_FULLBUF, NULL); |
| 862 |
return NULL; |
| 863 |
} |
| 864 |
conn->Data = g_realloc(conn->Data, conn->Length); |
| 865 |
} |
| 866 |
|
| 867 |
return (&conn->Data[conn->DataPresent]); |
| 868 |
} |
| 869 |
|
| 870 |
void CommitWriteBuffer(NetworkBuffer *NetBuf, ConnBuf *conn, |
| 871 |
gchar *addpt, guint addlen) |
| 872 |
{ |
| 873 |
conn->DataPresent += addlen; |
| 874 |
|
| 875 |
/* If the buffer was empty before, we may need to tell the owner to |
| 876 |
* check the socket for write-ready status */ |
| 877 |
if (NetBuf && addpt == conn->Data) |
| 878 |
NetBufCallBack(NetBuf, FALSE); |
| 879 |
} |
| 880 |
|
| 881 |
/* |
| 882 |
* Writes the null-terminated string "data" to the network buffer, ready |
| 883 |
* to be sent to the wire when the network connection becomes free. The |
| 884 |
* message is automatically terminated. Fails to write the message without |
| 885 |
* error if the buffer reaches its maximum size (although this error will |
| 886 |
* be detected when an attempt is made to write the buffer to the wire). |
| 887 |
*/ |
| 888 |
void QueueMessageForSend(NetworkBuffer *NetBuf, gchar *data) |
| 889 |
{ |
| 890 |
gchar *addpt; |
| 891 |
guint addlen; |
| 892 |
ConnBuf *conn; |
| 893 |
|
| 894 |
conn = &NetBuf->WriteBuf; |
| 895 |
|
| 896 |
if (!data) |
| 897 |
return; |
| 898 |
addlen = strlen(data) + 1; |
| 899 |
addpt = ExpandWriteBuffer(conn, addlen, NULL); |
| 900 |
if (!addpt) |
| 901 |
return; |
| 902 |
|
| 903 |
memcpy(addpt, data, addlen); |
| 904 |
addpt[addlen - 1] = NetBuf->Terminator; |
| 905 |
|
| 906 |
CommitWriteBuffer(NetBuf, conn, addpt, addlen); |
| 907 |
} |
| 908 |
|
| 909 |
static void SetNetworkError(LastError **error) { |
| 910 |
#ifdef CYGWIN |
| 911 |
SetError(error, ET_WINSOCK, WSAGetLastError(), NULL); |
| 912 |
#else |
| 913 |
SetError(error, ET_HERRNO, h_errno, NULL); |
| 914 |
#endif |
| 915 |
} |
| 916 |
|
| 917 |
static struct hostent *LookupHostname(const gchar *host, LastError **error) |
| 918 |
{ |
| 919 |
struct hostent *he; |
| 920 |
|
| 921 |
if ((he = gethostbyname(host)) == NULL && error) { |
| 922 |
SetNetworkError(error); |
| 923 |
} |
| 924 |
return he; |
| 925 |
} |
| 926 |
|
| 927 |
gboolean StartSocksNegotiation(NetworkBuffer *NetBuf, gchar *RemoteHost, |
| 928 |
unsigned RemotePort) |
| 929 |
{ |
| 930 |
guint num_methods; |
| 931 |
ConnBuf *conn; |
| 932 |
struct hostent *he; |
| 933 |
gchar *addpt; |
| 934 |
guint addlen, i; |
| 935 |
struct in_addr *haddr; |
| 936 |
unsigned short int netport; |
| 937 |
gchar *username = NULL; |
| 938 |
|
| 939 |
#ifdef CYGWIN |
| 940 |
DWORD bufsize; |
| 941 |
#else |
| 942 |
struct passwd *pwd; |
| 943 |
#endif |
| 944 |
|
| 945 |
conn = &NetBuf->negbuf; |
| 946 |
|
| 947 |
if (NetBuf->socks->version == 5) { |
| 948 |
num_methods = 1; |
| 949 |
if (NetBuf->userpasswd) |
| 950 |
num_methods++; |
| 951 |
addlen = 2 + num_methods; |
| 952 |
addpt = ExpandWriteBuffer(conn, addlen, &NetBuf->error); |
| 953 |
if (!addpt) |
| 954 |
return FALSE; |
| 955 |
addpt[0] = 5; /* SOCKS version 5 */ |
| 956 |
addpt[1] = num_methods; |
| 957 |
i = 2; |
| 958 |
addpt[i++] = SM_NOAUTH; |
| 959 |
if (NetBuf->userpasswd) |
| 960 |
addpt[i++] = SM_USERPASSWD; |
| 961 |
|
| 962 |
g_free(NetBuf->host); |
| 963 |
NetBuf->host = g_strdup(RemoteHost); |
| 964 |
NetBuf->port = RemotePort; |
| 965 |
|
| 966 |
CommitWriteBuffer(NetBuf, conn, addpt, addlen); |
| 967 |
|
| 968 |
return TRUE; |
| 969 |
} |
| 970 |
|
| 971 |
he = LookupHostname(RemoteHost, &NetBuf->error); |
| 972 |
if (!he) |
| 973 |
return FALSE; |
| 974 |
|
| 975 |
if (NetBuf->socks->user && NetBuf->socks->user[0]) { |
| 976 |
username = g_strdup(NetBuf->socks->user); |
| 977 |
} else { |
| 978 |
#ifdef CYGWIN |
| 979 |
bufsize = 0; |
| 980 |
WNetGetUser(NULL, username, &bufsize); |
| 981 |
if (GetLastError() != ERROR_MORE_DATA) { |
| 982 |
SetError(&NetBuf->error, ET_WIN32, GetLastError(), NULL); |
| 983 |
return FALSE; |
| 984 |
} else { |
| 985 |
username = g_malloc(bufsize); |
| 986 |
if (WNetGetUser(NULL, username, &bufsize) != NO_ERROR) { |
| 987 |
SetError(&NetBuf->error, ET_WIN32, GetLastError(), NULL); |
| 988 |
return FALSE; |
| 989 |
} |
| 990 |
} |
| 991 |
#else |
| 992 |
if (NetBuf->socks->numuid) { |
| 993 |
username = g_strdup_printf("%d", getuid()); |
| 994 |
} else { |
| 995 |
pwd = getpwuid(getuid()); |
| 996 |
if (!pwd || !pwd->pw_name) |
| 997 |
return FALSE; |
| 998 |
username = g_strdup(pwd->pw_name); |
| 999 |
} |
| 1000 |
#endif |
| 1001 |
} |
| 1002 |
addlen = 9 + strlen(username); |
| 1003 |
|
| 1004 |
haddr = (struct in_addr *)he->h_addr; |
| 1005 |
g_assert(sizeof(struct in_addr) == 4); |
| 1006 |
|
| 1007 |
netport = htons(RemotePort); |
| 1008 |
g_assert(sizeof(netport) == 2); |
| 1009 |
|
| 1010 |
addpt = ExpandWriteBuffer(conn, addlen, &NetBuf->error); |
| 1011 |
if (!addpt) |
| 1012 |
return FALSE; |
| 1013 |
|
| 1014 |
addpt[0] = 4; /* SOCKS version */ |
| 1015 |
addpt[1] = 1; /* CONNECT */ |
| 1016 |
memcpy(&addpt[2], &netport, sizeof(netport)); |
| 1017 |
memcpy(&addpt[4], haddr, sizeof(struct in_addr)); |
| 1018 |
strcpy(&addpt[8], username); |
| 1019 |
g_free(username); |
| 1020 |
addpt[addlen - 1] = '\0'; |
| 1021 |
|
| 1022 |
CommitWriteBuffer(NetBuf, conn, addpt, addlen); |
| 1023 |
|
| 1024 |
return TRUE; |
| 1025 |
} |
| 1026 |
|
| 1027 |
static gboolean WriteBufToWire(NetworkBuffer *NetBuf, ConnBuf *conn) |
| 1028 |
{ |
| 1029 |
int CurrentPosition, BytesSent; |
| 1030 |
|
| 1031 |
if (!conn->Data || !conn->DataPresent) |
| 1032 |
return TRUE; |
| 1033 |
if (conn->Length == MAXWRITEBUF) { |
| 1034 |
SetError(&NetBuf->error, ET_CUSTOM, E_FULLBUF, NULL); |
| 1035 |
return FALSE; |
| 1036 |
} |
| 1037 |
CurrentPosition = 0; |
| 1038 |
while (CurrentPosition < conn->DataPresent) { |
| 1039 |
BytesSent = send(NetBuf->fd, &conn->Data[CurrentPosition], |
| 1040 |
conn->DataPresent - CurrentPosition, 0); |
| 1041 |
if (BytesSent == SOCKET_ERROR) { |
| 1042 |
#ifdef CYGWIN |
| 1043 |
int Error = WSAGetLastError(); |
| 1044 |
|
| 1045 |
if (Error == WSAEWOULDBLOCK) |
| 1046 |
break; |
| 1047 |
else { |
| 1048 |
SetError(&NetBuf->error, ET_WINSOCK, Error, NULL); |
| 1049 |
return FALSE; |
| 1050 |
} |
| 1051 |
#else |
| 1052 |
if (errno == EAGAIN) |
| 1053 |
break; |
| 1054 |
else if (errno != EINTR) { |
| 1055 |
SetError(&NetBuf->error, ET_ERRNO, errno, NULL); |
| 1056 |
return FALSE; |
| 1057 |
} |
| 1058 |
#endif |
| 1059 |
} else { |
| 1060 |
CurrentPosition += BytesSent; |
| 1061 |
} |
| 1062 |
} |
| 1063 |
if (CurrentPosition > 0 && CurrentPosition < conn->DataPresent) { |
| 1064 |
memmove(&conn->Data[0], &conn->Data[CurrentPosition], |
| 1065 |
conn->DataPresent - CurrentPosition); |
| 1066 |
} |
| 1067 |
conn->DataPresent -= CurrentPosition; |
| 1068 |
return TRUE; |
| 1069 |
} |
| 1070 |
|
| 1071 |
/* |
| 1072 |
* Writes any waiting data in the network buffer to the wire. Returns |
| 1073 |
* TRUE on success, or FALSE if the buffer's maximum length is |
| 1074 |
* reached, or the remote end has closed the connection. |
| 1075 |
*/ |
| 1076 |
gboolean WriteDataToWire(NetworkBuffer *NetBuf) |
| 1077 |
{ |
| 1078 |
if (NetBuf->status == NBS_SOCKSCONNECT) { |
| 1079 |
return WriteBufToWire(NetBuf, &NetBuf->negbuf); |
| 1080 |
} else { |
| 1081 |
return WriteBufToWire(NetBuf, &NetBuf->WriteBuf); |
| 1082 |
} |
| 1083 |
} |
| 1084 |
|
| 1085 |
static size_t MetaConnWriteFunc(void *contents, size_t size, size_t nmemb, |
| 1086 |
void *userp) |
| 1087 |
{ |
| 1088 |
size_t realsize = size * nmemb; |
| 1089 |
CurlConnection *conn = (CurlConnection *)userp; |
| 1090 |
|
| 1091 |
conn->data = g_realloc(conn->data, conn->data_size + realsize + 1); |
| 1092 |
memcpy(&(conn->data[conn->data_size]), contents, realsize); |
| 1093 |
conn->data_size += realsize; |
| 1094 |
conn->data[conn->data_size] = 0; |
| 1095 |
|
| 1096 |
return realsize; |
| 1097 |
} |
| 1098 |
|
| 1099 |
static size_t MetaConnHeaderFunc(char *contents, size_t size, size_t nmemb, |
| 1100 |
void *userp) |
| 1101 |
{ |
| 1102 |
size_t realsize = size * nmemb; |
| 1103 |
CurlConnection *conn = (CurlConnection *)userp; |
| 1104 |
|
| 1105 |
gchar *str = g_strchomp(g_strndup(contents, realsize)); |
| 1106 |
g_ptr_array_add(conn->headers, (gpointer)str); |
| 1107 |
return realsize; |
| 1108 |
} |
| 1109 |
|
| 1110 |
void CurlInit(CurlConnection *conn) |
| 1111 |
{ |
| 1112 |
curl_global_init(CURL_GLOBAL_DEFAULT); |
| 1113 |
conn->multi = curl_multi_init(); |
| 1114 |
conn->h = curl_easy_init(); |
| 1115 |
conn->running = FALSE; |
| 1116 |
conn->Terminator = '\n'; |
| 1117 |
conn->StripChar = '\r'; |
| 1118 |
conn->data_size = 0; |
| 1119 |
conn->headers = NULL; |
| 1120 |
conn->timer_cb = NULL; |
| 1121 |
conn->socket_cb = NULL; |
| 1122 |
} |
| 1123 |
|
| 1124 |
void CloseCurlConnection(CurlConnection *conn) |
| 1125 |
{ |
| 1126 |
if (conn->running) { |
| 1127 |
curl_multi_remove_handle(conn->multi, conn->h); |
| 1128 |
g_free(conn->data); |
| 1129 |
conn->data_size = 0; |
| 1130 |
conn->running = FALSE; |
| 1131 |
g_ptr_array_free(conn->headers, TRUE); |
| 1132 |
conn->headers = NULL; |
| 1133 |
} |
| 1134 |
} |
| 1135 |
|
| 1136 |
void CurlCleanup(CurlConnection *conn) |
| 1137 |
{ |
| 1138 |
if (conn->running) { |
| 1139 |
CloseCurlConnection(conn); |
| 1140 |
} |
| 1141 |
curl_easy_cleanup(conn->h); |
| 1142 |
curl_multi_cleanup(conn->multi); |
| 1143 |
curl_global_cleanup(); |
| 1144 |
} |
| 1145 |
|
| 1146 |
gboolean HandleCurlMultiReturn(CurlConnection *conn, CURLMcode mres, |
| 1147 |
GError **err) |
| 1148 |
{ |
| 1149 |
struct CURLMsg *m; |
| 1150 |
if (mres != CURLM_OK && mres != CURLM_CALL_MULTI_PERFORM) { |
| 1151 |
CloseCurlConnection(conn); |
| 1152 |
g_set_error_literal(err, DOPE_CURLM_ERROR, mres, curl_multi_strerror(mres)); |
| 1153 |
return FALSE; |
| 1154 |
} |
| 1155 |
|
| 1156 |
do { |
| 1157 |
int msgq = 0; |
| 1158 |
m = curl_multi_info_read(conn->multi, &msgq); |
| 1159 |
if (m && m->msg == CURLMSG_DONE && m->data.result != CURLE_OK) { |
| 1160 |
CloseCurlConnection(conn); |
| 1161 |
g_set_error_literal(err, DOPE_CURL_ERROR, m->data.result, |
| 1162 |
curl_easy_strerror(m->data.result)); |
| 1163 |
return FALSE; |
| 1164 |
} |
| 1165 |
} while(m); |
| 1166 |
|
| 1167 |
return TRUE; |
| 1168 |
} |
| 1169 |
|
| 1170 |
gboolean CurlConnectionPerform(CurlConnection *conn, int *still_running, |
| 1171 |
GError **err) |
| 1172 |
{ |
| 1173 |
CURLMcode mres = curl_multi_perform(conn->multi, still_running); |
| 1174 |
return HandleCurlMultiReturn(conn, mres, err); |
| 1175 |
} |
| 1176 |
|
| 1177 |
gboolean CurlConnectionSocketAction(CurlConnection *conn, curl_socket_t fd, |
| 1178 |
int action, int *still_running, |
| 1179 |
GError **err) |
| 1180 |
{ |
| 1181 |
CURLMcode mres = curl_multi_socket_action(conn->multi, fd, action, |
| 1182 |
still_running); |
| 1183 |
return HandleCurlMultiReturn(conn, mres, err); |
| 1184 |
} |
| 1185 |
|
| 1186 |
GQuark dope_curl_error_quark(void) |
| 1187 |
{ |
| 1188 |
return g_quark_from_static_string("dope-curl-error-quark"); |
| 1189 |
} |
| 1190 |
|
| 1191 |
GQuark dope_curlm_error_quark(void) |
| 1192 |
{ |
| 1193 |
return g_quark_from_static_string("dope-curlm-error-quark"); |
| 1194 |
} |
| 1195 |
|
| 1196 |
gboolean CurlEasySetopt1(CURL *curl, CURLoption option, void *arg, GError **err) |
| 1197 |
{ |
| 1198 |
CURLcode res = curl_easy_setopt(curl, option, arg); |
| 1199 |
if (res == CURLE_OK) { |
| 1200 |
return TRUE; |
| 1201 |
} else { |
| 1202 |
g_set_error_literal(err, DOPE_CURL_ERROR, res, curl_easy_strerror(res)); |
| 1203 |
return FALSE; |
| 1204 |
} |
| 1205 |
} |
| 1206 |
|
| 1207 |
#ifdef CYGWIN |
| 1208 |
/* Set the path to TLS CA certificates. Without this, curl connections |
| 1209 |
to the metaserver may fail on Windows as it cannot verify the |
| 1210 |
certificate. |
| 1211 |
*/ |
| 1212 |
static gboolean SetCaInfo(CurlConnection *conn, GError **err) |
| 1213 |
{ |
| 1214 |
gchar *bindir, *cainfo; |
| 1215 |
gboolean ret; |
| 1216 |
|
| 1217 |
/* Point to a .crt file in the same directory as dopewars.exe */ |
| 1218 |
bindir = GetBinaryDir(); |
| 1219 |
cainfo = g_strdup_printf("%s\\ca-bundle.crt", bindir); |
| 1220 |
g_free(bindir); |
| 1221 |
|
| 1222 |
ret = CurlEasySetopt1(conn->h, CURLOPT_CAINFO, cainfo, err); |
| 1223 |
g_free(cainfo); |
| 1224 |
return ret; |
| 1225 |
} |
| 1226 |
#endif |
| 1227 |
|
| 1228 |
gboolean OpenCurlConnection(CurlConnection *conn, char *URL, char *body, |
| 1229 |
GError **err) |
| 1230 |
{ |
| 1231 |
/* If the previous connect hung for so long that it's still active, then |
| 1232 |
* break the connection before we start a new one */ |
| 1233 |
if (conn->running) { |
| 1234 |
CloseCurlConnection(conn); |
| 1235 |
} |
| 1236 |
|
| 1237 |
if (conn->h) { |
| 1238 |
int still_running; |
| 1239 |
CURLMcode mres; |
| 1240 |
if (body && !CurlEasySetopt1(conn->h, CURLOPT_COPYPOSTFIELDS, body, err)) { |
| 1241 |
return FALSE; |
| 1242 |
} |
| 1243 |
|
| 1244 |
if (!CurlEasySetopt1(conn->h, CURLOPT_URL, URL, err) |
| 1245 |
|| !CurlEasySetopt1(conn->h, CURLOPT_WRITEFUNCTION, MetaConnWriteFunc, |
| 1246 |
err) |
| 1247 |
|| !CurlEasySetopt1(conn->h, CURLOPT_WRITEDATA, conn, err) |
| 1248 |
|| !CurlEasySetopt1(conn->h, CURLOPT_HEADERFUNCTION, |
| 1249 |
MetaConnHeaderFunc, err) |
| 1250 |
#ifdef CYGWIN |
| 1251 |
|| !SetCaInfo(conn, err) |
| 1252 |
#endif |
| 1253 |
|| !CurlEasySetopt1(conn->h, CURLOPT_HEADERDATA, conn, err)) { |
| 1254 |
return FALSE; |
| 1255 |
} |
| 1256 |
|
| 1257 |
mres = curl_multi_add_handle(conn->multi, conn->h); |
| 1258 |
if (mres != CURLM_OK && mres != CURLM_CALL_MULTI_PERFORM) { |
| 1259 |
g_set_error_literal(err, DOPE_CURLM_ERROR, mres, |
| 1260 |
curl_multi_strerror(mres)); |
| 1261 |
return FALSE; |
| 1262 |
} |
| 1263 |
conn->data = g_malloc(1); |
| 1264 |
conn->data_size = 0; |
| 1265 |
conn->headers = g_ptr_array_new_with_free_func(g_free); |
| 1266 |
conn->running = TRUE; |
| 1267 |
if (conn->timer_cb) { |
| 1268 |
/* If we set a callback, we must not do _perform, but wait for the cb */ |
| 1269 |
return TRUE; |
| 1270 |
} else { |
| 1271 |
return CurlConnectionPerform(conn, &still_running, err); |
| 1272 |
} |
| 1273 |
} else { |
| 1274 |
g_set_error_literal(err, DOPE_CURLM_ERROR, 0, _("Could not init curl")); |
| 1275 |
return FALSE; |
| 1276 |
} |
| 1277 |
return TRUE; |
| 1278 |
} |
| 1279 |
|
| 1280 |
char *CurlNextLine(CurlConnection *conn, char *ch) |
| 1281 |
{ |
| 1282 |
char *sep_pt; |
| 1283 |
if (!ch) return NULL; |
| 1284 |
sep_pt = strchr(ch, conn->Terminator); |
| 1285 |
if (sep_pt) { |
| 1286 |
*sep_pt = '\0'; |
| 1287 |
if (sep_pt > ch && sep_pt[-1] == conn->StripChar) { |
| 1288 |
sep_pt[-1] = '\0'; |
| 1289 |
} |
| 1290 |
sep_pt++; |
| 1291 |
} |
| 1292 |
return sep_pt; |
| 1293 |
} |
| 1294 |
|
| 1295 |
/* Information associated with a specific socket */ |
| 1296 |
typedef struct _SockData { |
| 1297 |
GIOChannel *ch; |
| 1298 |
guint ev; |
| 1299 |
} SockData; |
| 1300 |
|
| 1301 |
static int timer_function(CURLM *multi, long timeout_ms, void *userp) |
| 1302 |
{ |
| 1303 |
CurlConnection *g = userp; |
| 1304 |
|
| 1305 |
if (g->timer_event) { |
| 1306 |
dp_g_source_remove(g->timer_event); |
| 1307 |
g->timer_event = 0; |
| 1308 |
} |
| 1309 |
|
| 1310 |
/* -1 means we should just delete our timer. */ |
| 1311 |
if (timeout_ms >= 0) { |
| 1312 |
g->timer_event = dp_g_timeout_add(timeout_ms, g->timer_cb, g); |
| 1313 |
} |
| 1314 |
return 0; |
| 1315 |
} |
| 1316 |
|
| 1317 |
/* Clean up the SockData structure */ |
| 1318 |
static void remsock(SockData *f) |
| 1319 |
{ |
| 1320 |
if (!f) { |
| 1321 |
return; |
| 1322 |
} |
| 1323 |
if (f->ev) { |
| 1324 |
dp_g_source_remove(f->ev); |
| 1325 |
} |
| 1326 |
g_io_channel_unref(f->ch); |
| 1327 |
g_free(f); |
| 1328 |
} |
| 1329 |
|
| 1330 |
/* Assign information to a SockData structure */ |
| 1331 |
static void setsock(SockData *f, curl_socket_t s, CURL *e, int act, |
| 1332 |
CurlConnection *g) |
| 1333 |
{ |
| 1334 |
GIOCondition kind = |
| 1335 |
((act & CURL_POLL_IN) ? G_IO_IN : 0) | |
| 1336 |
((act & CURL_POLL_OUT) ? G_IO_OUT : 0); |
| 1337 |
|
| 1338 |
if (f->ev) { |
| 1339 |
dp_g_source_remove(f->ev); |
| 1340 |
} |
| 1341 |
f->ev = dp_g_io_add_watch(f->ch, kind, g->socket_cb, g); |
| 1342 |
} |
| 1343 |
|
| 1344 |
/* Initialize a new SockData structure */ |
| 1345 |
static void addsock(curl_socket_t s, CURL *easy, int action, CurlConnection *g) |
| 1346 |
{ |
| 1347 |
SockData *fdp = g_malloc0(sizeof(SockData)); |
| 1348 |
|
| 1349 |
#ifdef CYGIN |
| 1350 |
fdp->ch = g_io_channel_win32_new_socket(s); |
| 1351 |
#else |
| 1352 |
fdp->ch = g_io_channel_unix_new(s); |
| 1353 |
#endif |
| 1354 |
setsock(fdp, s, easy, action, g); |
| 1355 |
curl_multi_assign(g->multi, s, fdp); |
| 1356 |
} |
| 1357 |
|
| 1358 |
static int socket_function(CURL *easy, curl_socket_t s, int what, void *userp, |
| 1359 |
void *socketp) |
| 1360 |
{ |
| 1361 |
CurlConnection *g = userp; |
| 1362 |
SockData *fdp = socketp; |
| 1363 |
if (what == CURL_POLL_REMOVE) { |
| 1364 |
remsock(fdp); |
| 1365 |
} else if (!fdp) { |
| 1366 |
addsock(s, easy, what, g); |
| 1367 |
} else { |
| 1368 |
setsock(fdp, s, easy, what, g); |
| 1369 |
} |
| 1370 |
return 0; |
| 1371 |
} |
| 1372 |
|
| 1373 |
void SetCurlCallback(CurlConnection *conn, GSourceFunc timer_cb, |
| 1374 |
GIOFunc socket_cb) |
| 1375 |
{ |
| 1376 |
conn->timer_event = 0; |
| 1377 |
conn->timer_cb = timer_cb; |
| 1378 |
conn->socket_cb = socket_cb; |
| 1379 |
|
| 1380 |
curl_multi_setopt(conn->multi, CURLMOPT_TIMERFUNCTION, timer_function); |
| 1381 |
curl_multi_setopt(conn->multi, CURLMOPT_TIMERDATA, conn); |
| 1382 |
curl_multi_setopt(conn->multi, CURLMOPT_SOCKETFUNCTION, socket_function); |
| 1383 |
curl_multi_setopt(conn->multi, CURLMOPT_SOCKETDATA, conn); |
| 1384 |
} |
| 1385 |
|
| 1386 |
int CreateTCPSocket(LastError **error) |
| 1387 |
{ |
| 1388 |
int fd; |
| 1389 |
|
| 1390 |
fd = socket(AF_INET, SOCK_STREAM, 0); |
| 1391 |
|
| 1392 |
if (fd == SOCKET_ERROR && error) { |
| 1393 |
SetNetworkError(error); |
| 1394 |
} |
| 1395 |
|
| 1396 |
return fd; |
| 1397 |
} |
| 1398 |
|
| 1399 |
gboolean BindTCPSocket(int sock, const gchar *addr, unsigned port, |
| 1400 |
LastError **error) |
| 1401 |
{ |
| 1402 |
struct sockaddr_in bindaddr; |
| 1403 |
int retval; |
| 1404 |
struct hostent *he; |
| 1405 |
|
| 1406 |
bindaddr.sin_family = AF_INET; |
| 1407 |
bindaddr.sin_port = htons(port); |
| 1408 |
if (addr && addr[0]) { |
| 1409 |
he = LookupHostname(addr, error); |
| 1410 |
if (!he) { |
| 1411 |
return FALSE; |
| 1412 |
} |
| 1413 |
bindaddr.sin_addr = *((struct in_addr *)he->h_addr); |
| 1414 |
} else { |
| 1415 |
bindaddr.sin_addr.s_addr = INADDR_ANY; |
| 1416 |
} |
| 1417 |
memset(bindaddr.sin_zero, 0, sizeof(bindaddr.sin_zero)); |
| 1418 |
|
| 1419 |
retval = |
| 1420 |
bind(sock, (struct sockaddr *)&bindaddr, sizeof(struct sockaddr)); |
| 1421 |
|
| 1422 |
if (retval == SOCKET_ERROR && error) { |
| 1423 |
SetNetworkError(error); |
| 1424 |
} |
| 1425 |
|
| 1426 |
return (retval != SOCKET_ERROR); |
| 1427 |
} |
| 1428 |
|
| 1429 |
gboolean StartConnect(int *fd, const gchar *bindaddr, gchar *RemoteHost, |
| 1430 |
unsigned RemotePort, gboolean *doneOK, LastError **error) |
| 1431 |
{ |
| 1432 |
struct sockaddr_in ClientAddr; |
| 1433 |
struct hostent *he; |
| 1434 |
|
| 1435 |
if (doneOK) |
| 1436 |
*doneOK = FALSE; |
| 1437 |
he = LookupHostname(RemoteHost, error); |
| 1438 |
if (!he) |
| 1439 |
return FALSE; |
| 1440 |
|
| 1441 |
*fd = CreateTCPSocket(error); |
| 1442 |
if (*fd == SOCKET_ERROR) |
| 1443 |
return FALSE; |
| 1444 |
|
| 1445 |
if (bindaddr && bindaddr[0] && !BindTCPSocket(*fd, bindaddr, 0, error)) { |
| 1446 |
return FALSE; |
| 1447 |
} |
| 1448 |
|
| 1449 |
ClientAddr.sin_family = AF_INET; |
| 1450 |
ClientAddr.sin_port = htons(RemotePort); |
| 1451 |
ClientAddr.sin_addr = *((struct in_addr *)he->h_addr); |
| 1452 |
memset(ClientAddr.sin_zero, 0, sizeof(ClientAddr.sin_zero)); |
| 1453 |
|
| 1454 |
SetBlocking(*fd, FALSE); |
| 1455 |
|
| 1456 |
if (connect(*fd, (struct sockaddr *)&ClientAddr, |
| 1457 |
sizeof(struct sockaddr)) == SOCKET_ERROR) { |
| 1458 |
#ifdef CYGWIN |
| 1459 |
int errcode = WSAGetLastError(); |
| 1460 |
|
| 1461 |
if (errcode == WSAEWOULDBLOCK) |
| 1462 |
return TRUE; |
| 1463 |
else if (error) |
| 1464 |
SetError(error, ET_WINSOCK, errcode, NULL); |
| 1465 |
#else |
| 1466 |
if (errno == EINPROGRESS) |
| 1467 |
return TRUE; |
| 1468 |
else if (error) |
| 1469 |
SetError(error, ET_ERRNO, errno, NULL); |
| 1470 |
#endif |
| 1471 |
CloseSocket(*fd); |
| 1472 |
*fd = -1; |
| 1473 |
return FALSE; |
| 1474 |
} else { |
| 1475 |
if (doneOK) |
| 1476 |
*doneOK = TRUE; |
| 1477 |
} |
| 1478 |
return TRUE; |
| 1479 |
} |
| 1480 |
|
| 1481 |
gboolean FinishConnect(int fd, LastError **error) |
| 1482 |
{ |
| 1483 |
int errcode; |
| 1484 |
|
| 1485 |
#ifdef CYGWIN |
| 1486 |
errcode = WSAGetLastError(); |
| 1487 |
if (errcode == 0) |
| 1488 |
return TRUE; |
| 1489 |
else { |
| 1490 |
if (error) { |
| 1491 |
SetError(error, ET_WINSOCK, errcode, NULL); |
| 1492 |
} |
| 1493 |
return FALSE; |
| 1494 |
} |
| 1495 |
#else |
| 1496 |
#ifdef HAVE_SOCKLEN_T |
| 1497 |
socklen_t optlen; |
| 1498 |
#else |
| 1499 |
int optlen; |
| 1500 |
#endif |
| 1501 |
|
| 1502 |
optlen = sizeof(errcode); |
| 1503 |
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &errcode, &optlen) == -1) { |
| 1504 |
errcode = errno; |
| 1505 |
} |
| 1506 |
if (errcode == 0) |
| 1507 |
return TRUE; |
| 1508 |
else { |
| 1509 |
if (error) { |
| 1510 |
SetError(error, ET_ERRNO, errcode, NULL); |
| 1511 |
} |
| 1512 |
return FALSE; |
| 1513 |
} |
| 1514 |
#endif /* CYGWIN */ |
| 1515 |
} |
| 1516 |
|
| 1517 |
static void AddB64char(GString *str, int c) |
| 1518 |
{ |
| 1519 |
if (c < 0) |
| 1520 |
return; |
| 1521 |
else if (c < 26) |
| 1522 |
g_string_append_c(str, c + 'A'); |
| 1523 |
else if (c < 52) |
| 1524 |
g_string_append_c(str, c - 26 + 'a'); |
| 1525 |
else if (c < 62) |
| 1526 |
g_string_append_c(str, c - 52 + '0'); |
| 1527 |
else if (c == 62) |
| 1528 |
g_string_append_c(str, '+'); |
| 1529 |
else |
| 1530 |
g_string_append_c(str, '/'); |
| 1531 |
} |
| 1532 |
|
| 1533 |
/* |
| 1534 |
* Adds the plain text string "unenc" to the end of the GString "str", |
| 1535 |
* using the Base64 encoding scheme. |
| 1536 |
*/ |
| 1537 |
void AddB64Enc(GString *str, gchar *unenc) |
| 1538 |
{ |
| 1539 |
guint i; |
| 1540 |
long value = 0; |
| 1541 |
|
| 1542 |
if (!unenc || !str) |
| 1543 |
return; |
| 1544 |
for (i = 0; i < strlen(unenc); i++) { |
| 1545 |
value <<= 8; |
| 1546 |
value |= (unsigned char)unenc[i]; |
| 1547 |
if (i % 3 == 2) { |
| 1548 |
AddB64char(str, (value >> 18) & 0x3F); |
| 1549 |
AddB64char(str, (value >> 12) & 0x3F); |
| 1550 |
AddB64char(str, (value >> 6) & 0x3F); |
| 1551 |
AddB64char(str, value & 0x3F); |
| 1552 |
value = 0; |
| 1553 |
} |
| 1554 |
} |
| 1555 |
if (i % 3 == 1) { |
| 1556 |
AddB64char(str, (value >> 2) & 0x3F); |
| 1557 |
AddB64char(str, (value << 4) & 0x3F); |
| 1558 |
g_string_append(str, "=="); |
| 1559 |
} else if (i % 3 == 2) { |
| 1560 |
AddB64char(str, (value >> 10) & 0x3F); |
| 1561 |
AddB64char(str, (value >> 4) & 0x3F); |
| 1562 |
AddB64char(str, (value << 2) & 0x3F); |
| 1563 |
g_string_append_c(str, '='); |
| 1564 |
} |
| 1565 |
} |
| 1566 |
|
| 1567 |
#endif /* NETWORKING */ |