| 76 |
|
write_links_file(void *notused) |
| 77 |
|
{ |
| 78 |
|
FILE *file = NULL; |
| 79 |
< |
dlink_node *ptr = NULL, *ptr_next = NULL;; |
| 79 |
> |
dlink_node *ptr = NULL, *ptr_next = NULL; |
| 80 |
|
char buff[IRCD_BUFSIZE] = { '\0' }; |
| 81 |
|
|
| 82 |
|
if ((file = fopen(LIPATH, "w")) == NULL) |
| 111 |
|
*/ |
| 112 |
|
snprintf(buff, sizeof(buff), "%s %s :1 %s", target_p->name, |
| 113 |
|
me.name, target_p->info); |
| 114 |
< |
dlinkAdd(xstrdup(buff), make_dlink_node(), &flatten_links); |
| 114 |
> |
dlinkAddTail(xstrdup(buff), make_dlink_node(), &flatten_links); |
| 115 |
|
snprintf(buff, sizeof(buff), "%s %s :1 %s\n", target_p->name, |
| 116 |
|
me.name, target_p->info); |
| 117 |
|
|
| 121 |
|
fclose(file); |
| 122 |
|
} |
| 123 |
|
|
| 124 |
+ |
void |
| 125 |
+ |
read_links_file(void) |
| 126 |
+ |
{ |
| 127 |
+ |
FILE *file = NULL; |
| 128 |
+ |
char *p = NULL; |
| 129 |
+ |
char buff[IRCD_BUFSIZE] = { '\0' }; |
| 130 |
+ |
|
| 131 |
+ |
if ((file = fopen(LIPATH, "r")) == NULL) |
| 132 |
+ |
return; |
| 133 |
+ |
|
| 134 |
+ |
while (fgets(buff, sizeof(buff), file)) |
| 135 |
+ |
{ |
| 136 |
+ |
if ((p = strchr(buff, '\n')) != NULL) |
| 137 |
+ |
*p = '\0'; |
| 138 |
+ |
|
| 139 |
+ |
dlinkAddTail(xstrdup(buff), make_dlink_node(), &flatten_links); |
| 140 |
+ |
} |
| 141 |
+ |
|
| 142 |
+ |
fclose(file); |
| 143 |
+ |
} |
| 144 |
+ |
|
| 145 |
|
/* hunt_server() |
| 146 |
|
* Do the basic thing in delivering the message (command) |
| 147 |
|
* across the relays to the specific server (server) for |
| 254 |
|
parv[1], parv[2], parv[3], parv[4], |
| 255 |
|
parv[5], parv[6], parv[7], parv[8]); |
| 256 |
|
return HUNTED_PASS; |
| 257 |
< |
} |
| 257 |
> |
} |
| 258 |
|
|
| 259 |
|
sendto_one(source_p, form_str(ERR_NOSUCHSERVER), |
| 260 |
|
me.name, source_p->name, parv[server]); |
| 288 |
|
|
| 289 |
|
assert(conf->type == CONF_SERVER); |
| 290 |
|
|
| 291 |
< |
/* Also when already connecting! (update holdtimes) --SRB |
| 291 |
> |
/* Also when already connecting! (update holdtimes) --SRB |
| 292 |
|
*/ |
| 293 |
|
if (!conf->port ||!IsConfAllowAutoConn(conf)) |
| 294 |
|
continue; |
| 399 |
|
|
| 400 |
|
/* XXX: Fix me for IPv6 */ |
| 401 |
|
/* XXX sockhost is the IPv4 ip as a string */ |
| 402 |
< |
if (!match(conf->host, client_p->host) || |
| 402 |
> |
if (!match(conf->host, client_p->host) || |
| 403 |
|
!match(conf->host, client_p->sockhost)) |
| 404 |
|
{ |
| 405 |
|
error = -2; |
| 407 |
|
if (!match_conf_password(client_p->localClient->passwd, conf)) |
| 408 |
|
return -2; |
| 409 |
|
|
| 410 |
+ |
if (!EmptyString(conf->certfp)) |
| 411 |
+ |
if (EmptyString(client_p->certfp) || strcasecmp(client_p->certfp, conf->certfp)) |
| 412 |
+ |
return -4; |
| 413 |
+ |
|
| 414 |
|
server_conf = conf; |
| 415 |
|
} |
| 416 |
|
} |
| 430 |
|
switch (server_conf->aftype) |
| 431 |
|
{ |
| 432 |
|
#ifdef IPV6 |
| 433 |
< |
case AF_INET6: |
| 433 |
> |
case AF_INET6: |
| 434 |
|
v6 = (struct sockaddr_in6 *)&server_conf->addr; |
| 435 |
|
|
| 436 |
|
if (IN6_IS_ADDR_UNSPECIFIED(&v6->sin6_addr)) |
| 441 |
|
v4 = (struct sockaddr_in *)&server_conf->addr; |
| 442 |
|
|
| 443 |
|
if (v4->sin_addr.s_addr == INADDR_NONE) |
| 444 |
< |
memcpy(&server_conf->addr, &client_p->localClient->ip, sizeof(struct irc_ssaddr)); |
| 444 |
> |
memcpy(&server_conf->addr, &client_p->localClient->ip, sizeof(struct irc_ssaddr)); |
| 445 |
|
break; |
| 446 |
|
} |
| 447 |
|
} |
| 561 |
|
} |
| 562 |
|
|
| 563 |
|
/* sendnick_TS() |
| 564 |
< |
* |
| 564 |
> |
* |
| 565 |
|
* inputs - client (server) to send nick towards |
| 566 |
|
* - client to send nick for |
| 567 |
|
* output - NONE |
| 620 |
|
target_p->servptr->name, target_p->info); |
| 621 |
|
} |
| 622 |
|
|
| 623 |
+ |
if (!EmptyString(target_p->certfp)) |
| 624 |
+ |
sendto_one(client_p, ":%s CERTFP %s", |
| 625 |
+ |
ID_or_name(target_p, client_p), target_p->certfp); |
| 626 |
+ |
|
| 627 |
|
if (target_p->away[0]) |
| 628 |
|
sendto_one(client_p, ":%s AWAY :%s", ID_or_name(target_p, client_p), |
| 629 |
|
target_p->away); |
| 638 |
|
* side effects - build up string representing capabilities of server listed |
| 639 |
|
*/ |
| 640 |
|
const char * |
| 641 |
< |
show_capabilities(struct Client *target_p) |
| 641 |
> |
show_capabilities(const struct Client *target_p) |
| 642 |
|
{ |
| 643 |
< |
static char msgbuf[IRCD_BUFSIZE]; |
| 644 |
< |
char *t = msgbuf; |
| 616 |
< |
dlink_node *ptr; |
| 643 |
> |
static char msgbuf[IRCD_BUFSIZE] = ""; |
| 644 |
> |
const dlink_node *ptr = NULL; |
| 645 |
|
|
| 646 |
< |
t += sprintf(msgbuf, "TS "); |
| 646 |
> |
strlcpy(msgbuf, "TS", sizeof(msgbuf)); |
| 647 |
|
|
| 648 |
|
DLINK_FOREACH(ptr, cap_list.head) |
| 649 |
|
{ |
| 650 |
|
const struct Capability *cap = ptr->data; |
| 651 |
|
|
| 652 |
< |
if (IsCapable(target_p, cap->cap)) |
| 653 |
< |
t += sprintf(t, "%s ", cap->name); |
| 652 |
> |
if (!IsCapable(target_p, cap->cap)) |
| 653 |
> |
continue; |
| 654 |
> |
|
| 655 |
> |
strlcat(msgbuf, " ", sizeof(msgbuf)); |
| 656 |
> |
strlcat(msgbuf, cap->name, sizeof(msgbuf)); |
| 657 |
|
} |
| 658 |
|
|
| 628 |
– |
*(t - 1) = '\0'; |
| 659 |
|
return msgbuf; |
| 660 |
|
} |
| 661 |
|
|
| 721 |
|
/* If there is something in the serv_list, it might be this |
| 722 |
|
* connecting server.. |
| 723 |
|
*/ |
| 724 |
< |
if (!ServerInfo.hub && serv_list.head) |
| 724 |
> |
if (!ServerInfo.hub && serv_list.head) |
| 725 |
|
{ |
| 726 |
|
if (client_p != serv_list.head->data || serv_list.head->next) |
| 727 |
|
{ |
| 854 |
|
IsHidden(client_p) ? "(H) " : "", |
| 855 |
|
client_p->info); |
| 856 |
|
else |
| 857 |
< |
sendto_one(target_p,":%s SERVER %s 2 :%s%s", |
| 857 |
> |
sendto_one(target_p,":%s SERVER %s 2 :%s%s", |
| 858 |
|
me.name, client_p->name, |
| 859 |
|
IsHidden(client_p) ? "(H) " : "", |
| 860 |
|
client_p->info); |
| 861 |
|
} |
| 862 |
|
|
| 863 |
< |
/* Pass on my client information to the new server |
| 864 |
< |
** |
| 865 |
< |
** First, pass only servers (idea is that if the link gets |
| 866 |
< |
** cancelled beacause the server was already there, |
| 867 |
< |
** there are no NICK's to be cancelled...). Of course, |
| 868 |
< |
** if cancellation occurs, all this info is sent anyway, |
| 869 |
< |
** and I guess the link dies when a read is attempted...? --msa |
| 870 |
< |
** |
| 871 |
< |
** Note: Link cancellation to occur at this point means |
| 872 |
< |
** that at least two servers from my fragment are building |
| 873 |
< |
** up connection this other fragment at the same time, it's |
| 874 |
< |
** a race condition, not the normal way of operation... |
| 875 |
< |
** |
| 876 |
< |
** ALSO NOTE: using the get_client_name for server names-- |
| 877 |
< |
** see previous *WARNING*!!! (Also, original inpath |
| 878 |
< |
** is destroyed...) |
| 879 |
< |
*/ |
| 863 |
> |
/* |
| 864 |
> |
* Pass on my client information to the new server |
| 865 |
> |
* |
| 866 |
> |
* First, pass only servers (idea is that if the link gets |
| 867 |
> |
* cancelled beacause the server was already there, |
| 868 |
> |
* there are no NICK's to be cancelled...). Of course, |
| 869 |
> |
* if cancellation occurs, all this info is sent anyway, |
| 870 |
> |
* and I guess the link dies when a read is attempted...? --msa |
| 871 |
> |
* |
| 872 |
> |
* Note: Link cancellation to occur at this point means |
| 873 |
> |
* that at least two servers from my fragment are building |
| 874 |
> |
* up connection this other fragment at the same time, it's |
| 875 |
> |
* a race condition, not the normal way of operation... |
| 876 |
> |
* |
| 877 |
> |
* ALSO NOTE: using the get_client_name for server names-- |
| 878 |
> |
* see previous *WARNING*!!! (Also, original inpath |
| 879 |
> |
* is destroyed...) |
| 880 |
> |
*/ |
| 881 |
|
|
| 882 |
|
DLINK_FOREACH_PREV(ptr, global_serv_list.tail) |
| 883 |
|
{ |
| 900 |
|
IsHidden(target_p) ? "(H) " : "", target_p->info); |
| 901 |
|
} |
| 902 |
|
else |
| 903 |
< |
sendto_one(client_p, ":%s SERVER %s %d :%s%s", |
| 903 |
> |
sendto_one(client_p, ":%s SERVER %s %d :%s%s", |
| 904 |
|
target_p->servptr->name, target_p->name, target_p->hopcount+1, |
| 905 |
|
IsHidden(target_p) ? "(H) " : "", target_p->info); |
| 906 |
|
|
| 941 |
|
|
| 942 |
|
/* burst_all() |
| 943 |
|
* |
| 944 |
< |
* inputs - pointer to server to send burst to |
| 944 |
> |
* inputs - pointer to server to send burst to |
| 945 |
|
* output - NONE |
| 946 |
|
* side effects - complete burst of channels/nicks is sent to client_p |
| 947 |
|
*/ |
| 972 |
|
|
| 973 |
|
if (!HasFlag(target_p, FLAGS_BURSTED) && target_p->from != client_p) |
| 974 |
|
sendnick_TS(client_p, target_p); |
| 975 |
< |
|
| 975 |
> |
|
| 976 |
|
DelFlag(target_p, FLAGS_BURSTED); |
| 977 |
|
} |
| 978 |
|
|
| 1050 |
|
|
| 1051 |
|
/* serv_connect() - initiate a server connection |
| 1052 |
|
* |
| 1053 |
< |
* inputs - pointer to conf |
| 1053 |
> |
* inputs - pointer to conf |
| 1054 |
|
* - pointer to client doing the connect |
| 1055 |
|
* output - |
| 1056 |
|
* side effects - |
| 1102 |
|
* Note: conf should ALWAYS be a valid C: line |
| 1103 |
|
*/ |
| 1104 |
|
if ((client_p = hash_find_server(conf->name)) != NULL) |
| 1105 |
< |
{ |
| 1105 |
> |
{ |
| 1106 |
|
sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE, |
| 1107 |
|
"Server %s already present from %s", |
| 1108 |
|
conf->name, get_client_name(client_p, SHOW_IP)); |
| 1115 |
|
get_client_name(client_p, MASK_IP)); |
| 1116 |
|
return 0; |
| 1117 |
|
} |
| 1118 |
< |
|
| 1118 |
> |
|
| 1119 |
|
/* Create a local client */ |
| 1120 |
|
client_p = make_client(NULL); |
| 1121 |
|
|
| 1126 |
|
/* We already converted the ip once, so lets use it - stu */ |
| 1127 |
|
strlcpy(client_p->sockhost, buf, sizeof(client_p->sockhost)); |
| 1128 |
|
|
| 1129 |
< |
/* create a socket for the server connection */ |
| 1129 |
> |
/* create a socket for the server connection */ |
| 1130 |
|
if (comm_open(&client_p->localClient->fd, conf->addr.ss.ss_family, |
| 1131 |
|
SOCK_STREAM, 0, NULL) < 0) |
| 1132 |
|
{ |
| 1149 |
|
sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE, |
| 1150 |
|
"Host %s is not enabled for connecting: no connect{} block", |
| 1151 |
|
conf->name); |
| 1152 |
< |
if (by && IsClient(by) && !MyClient(by)) |
| 1152 |
> |
if (by && IsClient(by) && !MyClient(by)) |
| 1153 |
|
sendto_one(by, ":%s NOTICE %s :Connect to host %s failed.", |
| 1154 |
|
me.name, by->name, client_p->name); |
| 1155 |
|
SetDead(client_p); |
| 1176 |
|
client_p->localClient->aftype = conf->aftype; |
| 1177 |
|
|
| 1178 |
|
/* Now, initiate the connection */ |
| 1179 |
< |
/* XXX assume that a non 0 type means a specific bind address |
| 1179 |
> |
/* XXX assume that a non 0 type means a specific bind address |
| 1180 |
|
* for this connect. |
| 1181 |
|
*/ |
| 1182 |
|
switch (conf->aftype) |
| 1191 |
|
ipn.ss_port = 0; |
| 1192 |
|
memcpy(&ipn, &conf->bind, sizeof(struct irc_ssaddr)); |
| 1193 |
|
comm_connect_tcp(&client_p->localClient->fd, conf->host, conf->port, |
| 1194 |
< |
(struct sockaddr *)&ipn, ipn.ss_len, |
| 1194 |
> |
(struct sockaddr *)&ipn, ipn.ss_len, |
| 1195 |
|
serv_connect_callback, client_p, conf->aftype, |
| 1196 |
|
CONNECTTIMEOUT); |
| 1197 |
|
} |
| 1208 |
|
CONNECTTIMEOUT); |
| 1209 |
|
} |
| 1210 |
|
else |
| 1211 |
< |
comm_connect_tcp(&client_p->localClient->fd, conf->host, conf->port, |
| 1212 |
< |
NULL, 0, serv_connect_callback, client_p, conf->aftype, |
| 1211 |
> |
comm_connect_tcp(&client_p->localClient->fd, conf->host, conf->port, |
| 1212 |
> |
NULL, 0, serv_connect_callback, client_p, conf->aftype, |
| 1213 |
|
CONNECTTIMEOUT); |
| 1214 |
|
break; |
| 1215 |
|
#ifdef IPV6 |
| 1230 |
|
ipn.ss_port = 0; |
| 1231 |
|
comm_connect_tcp(&client_p->localClient->fd, |
| 1232 |
|
conf->host, conf->port, |
| 1233 |
< |
(struct sockaddr *)&ipn, ipn.ss_len, |
| 1233 |
> |
(struct sockaddr *)&ipn, ipn.ss_len, |
| 1234 |
|
serv_connect_callback, client_p, |
| 1235 |
|
conf->aftype, CONNECTTIMEOUT); |
| 1236 |
|
} |
| 1247 |
|
} |
| 1248 |
|
else |
| 1249 |
|
comm_connect_tcp(&client_p->localClient->fd, |
| 1250 |
< |
conf->host, conf->port, |
| 1250 |
> |
conf->host, conf->port, |
| 1251 |
|
NULL, 0, serv_connect_callback, client_p, |
| 1252 |
|
conf->aftype, CONNECTTIMEOUT); |
| 1253 |
|
} |
| 1305 |
|
static void |
| 1306 |
|
ssl_server_handshake(fde_t *fd, struct Client *client_p) |
| 1307 |
|
{ |
| 1308 |
< |
int ret; |
| 1309 |
< |
int err; |
| 1279 |
< |
|
| 1280 |
< |
ret = SSL_connect(client_p->localClient->fd.ssl); |
| 1308 |
> |
X509 *cert = NULL; |
| 1309 |
> |
int ret = 0; |
| 1310 |
|
|
| 1311 |
< |
if (ret <= 0) |
| 1311 |
> |
if ((ret = SSL_connect(client_p->localClient->fd.ssl)) <= 0) |
| 1312 |
|
{ |
| 1313 |
< |
switch ((err = SSL_get_error(client_p->localClient->fd.ssl, ret))) |
| 1313 |
> |
switch (SSL_get_error(client_p->localClient->fd.ssl, ret)) |
| 1314 |
|
{ |
| 1315 |
|
case SSL_ERROR_WANT_WRITE: |
| 1316 |
|
comm_setselect(&client_p->localClient->fd, COMM_SELECT_WRITE, |
| 1332 |
|
} |
| 1333 |
|
} |
| 1334 |
|
|
| 1335 |
+ |
if ((cert = SSL_get_peer_certificate(client_p->localClient->fd.ssl))) |
| 1336 |
+ |
{ |
| 1337 |
+ |
int res = SSL_get_verify_result(client_p->localClient->fd.ssl); |
| 1338 |
+ |
char buf[EVP_MAX_MD_SIZE * 2 + 1] = { '\0' }; |
| 1339 |
+ |
unsigned char md[EVP_MAX_MD_SIZE] = { '\0' }; |
| 1340 |
+ |
|
| 1341 |
+ |
if (res == X509_V_OK || res == X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN || |
| 1342 |
+ |
res == X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE || |
| 1343 |
+ |
res == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) |
| 1344 |
+ |
{ |
| 1345 |
+ |
unsigned int i = 0, n = 0; |
| 1346 |
+ |
|
| 1347 |
+ |
if (X509_digest(cert, EVP_sha256(), md, &n)) |
| 1348 |
+ |
{ |
| 1349 |
+ |
for (; i < n; ++i) |
| 1350 |
+ |
snprintf(buf + 2 * i, 3, "%02X", md[i]); |
| 1351 |
+ |
client_p->certfp = xstrdup(buf); |
| 1352 |
+ |
} |
| 1353 |
+ |
} |
| 1354 |
+ |
else |
| 1355 |
+ |
ilog(LOG_TYPE_IRCD, "Server %s!%s@%s gave bad SSL client certificate: %d", |
| 1356 |
+ |
client_p->name, client_p->username, client_p->host, res); |
| 1357 |
+ |
X509_free(cert); |
| 1358 |
+ |
} |
| 1359 |
+ |
|
| 1360 |
|
finish_ssl_server_handshake(client_p); |
| 1361 |
|
} |
| 1362 |
|
|
| 1382 |
|
#endif |
| 1383 |
|
|
| 1384 |
|
/* serv_connect_callback() - complete a server connection. |
| 1385 |
< |
* |
| 1385 |
> |
* |
| 1386 |
|
* This routine is called after the server connection attempt has |
| 1387 |
|
* completed. If unsucessful, an error is sent to ops and the client |
| 1388 |
|
* is closed. If sucessful, it goes through the initialisation/check |
| 1464 |
|
/* If we've been marked dead because a send failed, just exit |
| 1465 |
|
* here now and save everyone the trouble of us ever existing. |
| 1466 |
|
*/ |
| 1467 |
< |
if (IsDead(client_p)) |
| 1467 |
> |
if (IsDead(client_p)) |
| 1468 |
|
{ |
| 1469 |
|
sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE, |
| 1470 |
|
"%s[%s] went dead during handshake", |
| 1494 |
|
if (!match(name, cptr->name)) |
| 1495 |
|
return cptr; |
| 1496 |
|
} |
| 1497 |
< |
|
| 1497 |
> |
|
| 1498 |
|
return NULL; |
| 1499 |
|
} |