Lines Matching defs:server
94 static int open_tcp_socket(ares_channel channel, struct server_state *server);
95 static int open_udp_socket(ares_channel channel, struct server_state *server);
211 struct server_state *server;
225 /* Make sure server has data to send and is selected in write_fds or
227 server = &channel->servers[i];
228 if (!server->qhead || server->tcp_socket == ARES_SOCKET_BAD ||
229 server->is_broken)
233 if(!FD_ISSET(server->tcp_socket, write_fds))
237 if(server->tcp_socket != write_fd)
243 * another with the same fd to talk to another server, then we
247 FD_CLR(server->tcp_socket, write_fds);
251 for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
260 for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
266 wcount = (ssize_t)writev(server->tcp_socket, vec, (int)n);
281 sendreq = server->qhead;
283 scount = swrite(server->tcp_socket, sendreq->data, sendreq->len);
302 struct server_state *server = &channel->servers[whichserver];
304 sendreq = server->qhead;
307 server->qhead = sendreq->next;
311 if (server->qhead == NULL) {
312 SOCK_STATE_CALLBACK(channel, server->tcp_socket, 1, 0);
313 server->qtail = NULL;
334 struct server_state *server;
344 /* Make sure the server has a socket and is selected in read_fds. */
345 server = &channel->servers[i];
346 if (server->tcp_socket == ARES_SOCKET_BAD || server->is_broken)
350 if(!FD_ISSET(server->tcp_socket, read_fds))
354 if(server->tcp_socket != read_fd)
360 * another with the same fd to talk to another server, then we
364 FD_CLR(server->tcp_socket, read_fds);
366 if (server->tcp_lenbuf_pos != 2)
371 count = sread(server->tcp_socket,
372 server->tcp_lenbuf + server->tcp_lenbuf_pos,
373 2 - server->tcp_lenbuf_pos);
381 server->tcp_lenbuf_pos += (int)count;
382 if (server->tcp_lenbuf_pos == 2)
387 server->tcp_length = server->tcp_lenbuf[0] << 8
388 | server->tcp_lenbuf[1];
389 server->tcp_buffer = malloc(server->tcp_length);
390 if (!server->tcp_buffer)
392 server->tcp_buffer_pos = 0;
398 count = sread(server->tcp_socket,
399 server->tcp_buffer + server->tcp_buffer_pos,
400 server->tcp_length - server->tcp_buffer_pos);
408 server->tcp_buffer_pos += (int)count;
409 if (server->tcp_buffer_pos == server->tcp_length)
414 process_answer(channel, server->tcp_buffer, server->tcp_length,
416 if (server->tcp_buffer)
417 free(server->tcp_buffer);
418 server->tcp_buffer = NULL;
419 server->tcp_lenbuf_pos = 0;
420 server->tcp_buffer_pos = 0;
430 struct server_state *server;
449 /* Make sure the server has a socket and is selected in read_fds. */
450 server = &channel->servers[i];
452 if (server->udp_socket == ARES_SOCKET_BAD || server->is_broken)
456 if(!FD_ISSET(server->udp_socket, read_fds))
460 if(server->udp_socket != read_fd)
466 * another with the same fd to talk to another server, then we
470 FD_CLR(server->udp_socket, read_fds);
476 if (server->addr.family == AF_INET)
480 count = (ssize_t)recvfrom(server->udp_socket, (void *)buf, sizeof(buf),
483 count = sread(server->udp_socket, buf, sizeof(buf));
490 else if (!same_address(&from.sa, &server->addr))
534 /* Handle an answer from a server. */
605 if (query->server == whichserver)
621 struct server_state *server = &channel->servers[i];
622 if (server->is_broken)
632 struct server_state *server;
637 server = &channel->servers[whichserver];
639 /* Reset communications with this server. */
640 ares__close_sockets(channel, server);
642 /* Tell all queries talking to this server to move on and not try
643 * this server again. We steal the current list of queries that were
644 * in-flight to this server, since when we call next_server this can
645 * cause the queries to be re-sent to this server, which will
646 * re-insert these queries in that same server->queries_to_server
650 ares__swap_lists(&list_head, &(server->queries_to_server));
655 assert(query->server == whichserver);
667 /* The given server gave us problems with this query, so if we have
669 * potentially broken server and just use the others. If we only
670 * have one server and we need to retry then we should just go ahead
671 * and re-use that server, since it's our only hope; perhaps we
672 * just got unlucky, and retrying will work (eg, the server timed
684 /* We need to try each server channel->tries times. We have channel->nservers
687 * this query. Use modular arithmetic to find the next server to try. */
690 struct server_state *server;
692 /* Move on to the next server. */
693 query->server = (query->server + 1) % channel->nservers;
694 server = &channel->servers[query->server];
696 /* We don't want to use this server if (1) we decided this
698 * we've decided to skip this server because of earlier
702 if (!server->is_broken &&
703 !query->server_info[query->server].skip_server &&
705 (query->server_info[query->server].tcp_connection_generation ==
706 server->tcp_connection_generation)))
728 struct server_state *server;
731 server = &channel->servers[query->server];
734 /* Make sure the TCP socket for this server is set up and queue
737 if (server->tcp_socket == ARES_SOCKET_BAD)
739 if (open_tcp_socket(channel, server) == -1)
741 skip_server(channel, query, query->server);
763 if (server->qtail)
764 server->qtail->next = sendreq;
767 SOCK_STATE_CALLBACK(channel, server->tcp_socket, 1, 1);
768 server->qhead = sendreq;
770 server->qtail = sendreq;
771 query->server_info[query->server].tcp_connection_generation =
772 server->tcp_connection_generation;
776 if (server->udp_socket == ARES_SOCKET_BAD)
778 if (open_udp_socket(channel, server) == -1)
780 skip_server(channel, query, query->server);
785 if (swrite(server->udp_socket, query->qbuf, query->qlen) == -1)
788 skip_server(channel, query, query->server);
807 /* Keep track of queries bucketed by server, so we can process server
812 &(server->queries_to_server));
932 static int open_tcp_socket(ares_channel channel, struct server_state *server)
943 switch (server->addr.family)
951 memcpy(&saddr.sa4.sin_addr, &server->addr.addrV4,
952 sizeof(server->addr.addrV4));
960 memcpy(&saddr.sa6.sin6_addr, &server->addr.addrV6,
961 sizeof(server->addr.addrV6));
968 s = socket(server->addr.family, SOCK_STREAM, 0);
973 if (configure_socket(s, server->addr.family, channel) < 0)
995 /* Connect to the server. */
1019 server->tcp_buffer_pos = 0;
1020 server->tcp_socket = s;
1021 server->tcp_connection_generation = ++channel->tcp_connection_generation;
1025 static int open_udp_socket(ares_channel channel, struct server_state *server)
1035 switch (server->addr.family)
1043 memcpy(&saddr.sa4.sin_addr, &server->addr.addrV4,
1044 sizeof(server->addr.addrV4));
1052 memcpy(&saddr.sa6.sin6_addr, &server->addr.addrV6,
1053 sizeof(server->addr.addrV6));
1060 s = socket(server->addr.family, SOCK_DGRAM, 0);
1065 if (configure_socket(s, server->addr.family, channel) < 0)
1071 /* Connect to the server. */
1096 server->udp_socket = s;
1217 struct server_state *server = &channel->servers[i];
1219 for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
1250 * suggesting the DNS server we're talking to is
1256 * server.
1258 server->is_broken = 1;
