void smart_link_event(enum sl_event event, int sock) { switch (event) { case SL_EVENT: { smart_link_log_event("sl-event event, fd(%d).\n", sock); thread_add_read(sl_master, smart_link_recv_event, NULL, sock); break; } case SL_MSG: { smart_link_log_event("sl-event msg, fd(%d).\n", sock); thread_add_read(sl_master, smart_link_recv_msg, NULL, sock); break; } case SL_DBUS_READ: { smart_link_log_event("sl-event dbus-read, fd(%d).\n", sock); thread_add_read(sl_master, smart_link_recv_cmd, NULL, sock); break; } case SL_DBUS_WRITE: { smart_link_log_event("sl-event dbus-write, fd(%d).\n", sock); thread_add_write(sl_master, smart_link_send_cmd, NULL, sock); break; } default : { smart_link_log_error("sl-event default, fd(%d).\n", sock); break; } } }
/* * Read get result from the remote web server. * Apply trigger check to this result. */ int http_response_thread(thread_t * thread) { SOCK *sock_obj = THREAD_ARG(thread); /* Handle read timeout */ if (thread->type == THREAD_READ_TIMEOUT) return epilog(thread); /* Allocate & clean the get buffer */ sock_obj->buffer = (char *) MALLOC(MAX_BUFFER_LENGTH); /* Initalize the hash context */ sock_obj->hash = &hashes[req->hash]; HASH_INIT(sock_obj); /* Register asynchronous http/ssl read thread */ if (req->ssl) thread_add_read(thread->master, ssl_read_thread, sock_obj, thread->u.fd, HTTP_CNX_TIMEOUT); else thread_add_read(thread->master, http_read_thread, sock_obj, thread->u.fd, HTTP_CNX_TIMEOUT); return 0; }
int ospf_if_up (struct ospf_interface *oi) { if (oi == NULL) return 0; if (oi->type == OSPF_IFTYPE_LOOPBACK) OSPF_ISM_EVENT_SCHEDULE (oi, ISM_LoopInd); else { //struct ospf *ospf = ospf_lookup (); struct ospf *ospf = oi->ospf; if (ospf != NULL) ospf_adjust_sndbuflen_oisock (ospf, oi->ifp->mtu,oi); else ; //zlog_warn ("%s: ospf_lookup() returned NULL", __func__); ospf_if_stream_set (oi); OSPF_ISM_EVENT_SCHEDULE (oi, ISM_InterfaceUp); } if(oi->t_packet_read == NULL) oi->t_packet_read = thread_add_read (master, ospf_read_oisock, oi, oi->packet_fd); return 1; }
void kernel_netlink_init(void) { /* Start with a netlink address lookup */ netlink_address_lookup(); /* * Prepare netlink kernel broadcast channel * subscribtion. We subscribe to LINK and ADDR * netlink broadcast messages. */ netlink_socket(&nl_kernel, SOCK_NONBLOCK, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR, RTNLGRP_IPV6_IFADDR, 0); if (nl_kernel.fd > 0) { log_message(LOG_INFO, "Registering Kernel netlink reflector"); nl_kernel.thread = thread_add_read(master, kernel_netlink, &nl_kernel, nl_kernel.fd, NETLINK_TIMER); } else log_message(LOG_INFO, "Error while registering Kernel netlink reflector channel"); /* Prepare netlink command channel. */ netlink_socket(&nl_cmd, SOCK_NONBLOCK, 0); if (nl_cmd.fd > 0) log_message(LOG_INFO, "Registering Kernel netlink command channel"); else log_message(LOG_INFO, "Error while registering Kernel netlink cmd channel"); }
static int babel_create_routing_process (void) { assert (babel_routing_process == NULL); /* Allocaste Babel instance. */ babel_routing_process = XCALLOC (MTYPE_BABEL, sizeof (struct babel)); /* Initialize timeouts */ gettime(&babel_now); expiry_time = babel_now.tv_sec + roughly(30); source_expiry_time = babel_now.tv_sec + roughly(300); /* Make socket for Babel protocol. */ protocol_socket = babel_socket(protocol_port); if (protocol_socket < 0) { zlog_err("Couldn't create link local socket: %s", safe_strerror(errno)); goto fail; } /* Threads. */ babel_routing_process->t_read = thread_add_read(master, &babel_read_protocol, NULL, protocol_socket); /* wait a little: zebra will announce interfaces, addresses, routes... */ babel_routing_process->t_update = thread_add_timer_msec(master, babel_init_routing_process, NULL, 200L); schedule_auth_housekeeping(); return 0; fail: XFREE(MTYPE_BABEL, babel_routing_process); babel_routing_process = NULL; return -1; }
/* Make routing socket. */ static void routing_socket (void) { if ( zserv_privs.change (ZPRIVS_RAISE) ) zlog_err ("routing_socket: Can't raise privileges"); routing_sock = socket (AF_ROUTE, SOCK_RAW, 0); if (routing_sock < 0) { if ( zserv_privs.change (ZPRIVS_LOWER) ) zlog_err ("routing_socket: Can't lower privileges"); zlog_warn ("Can't init kernel routing socket"); return; } /* XXX: Socket should be NONBLOCK, however as we currently * discard failed writes, this will lead to inconsistencies. * For now, socket must be blocking. */ /*if (fcntl (routing_sock, F_SETFL, O_NONBLOCK) < 0) zlog_warn ("Can't set O_NONBLOCK to routing socket");*/ if ( zserv_privs.change (ZPRIVS_LOWER) ) zlog_err ("routing_socket: Can't lower privileges"); /* kernel_read needs rewrite. */ thread_add_read (zebrad.master, kernel_read, NULL, routing_sock); }
/* thread reading entries form others babel daemons */ static int babel_read_protocol (struct thread *thread) { int rc; struct interface *ifp = NULL; struct sockaddr_in6 sin6; struct listnode *linklist_node = NULL; assert(babel_routing_process != NULL); assert(protocol_socket >= 0); rc = babel_recv(protocol_socket, receive_buffer, receive_buffer_size, (struct sockaddr*)&sin6, sizeof(sin6)); if(rc < 0) { if(errno != EAGAIN && errno != EINTR) { zlog_err("recv: %s", safe_strerror(errno)); } } else { FOR_ALL_INTERFACES(ifp, linklist_node) { if(!if_up(ifp)) continue; if(ifp->ifindex == sin6.sin6_scope_id) { parse_packet((unsigned char*)&sin6.sin6_addr, ifp, receive_buffer, rc); break; } } } /* re-add thread */ babel_routing_process->t_read = thread_add_read(master, &babel_read_protocol, NULL, protocol_socket); return 0; }
void kernel_netlink_init(void) { unsigned long groups; /* Start with a netlink address lookup */ netlink_address_lookup(); /* * Prepare netlink kernel broadcast channel * subscribtion. We subscribe to LINK and ADDR * netlink broadcast messages. */ groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR; netlink_socket(&nl_kernel, groups); if (nl_kernel.fd > 0) { log_message(LOG_INFO, "Registering Kernel netlink reflector"); thread_add_read(master, kernel_netlink, NULL, nl_kernel.fd, NETLINK_TIMER); } else log_message(LOG_INFO, "Error while registering Kernel netlink reflector channel"); /* Prepare netlink command channel. */ netlink_socket(&nl_cmd, 0); if (nl_cmd.fd > 0) log_message(LOG_INFO, "Registering Kernel netlink command channel"); else log_message(LOG_INFO, "Error while registering Kernel netlink cmd channel"); }
static void zclient_event (enum event event, struct zclient *zclient) { switch (event) { case ZCLIENT_SCHEDULE: if (! zclient->t_connect) zclient->t_connect = thread_add_event (master, zclient_connect, zclient, 0); break; case ZCLIENT_CONNECT: if (zclient->fail >= 10) return; if (zclient_debug) zlog_debug ("zclient connect schedule interval is %d", zclient->fail < 3 ? 10 : 60); if (! zclient->t_connect) zclient->t_connect = thread_add_timer (master, zclient_connect, zclient, zclient->fail < 3 ? 10 : 60); break; case ZCLIENT_READ: zclient->t_read = thread_add_read (master, zclient_read, zclient, zclient->sock); break; } }
static int smtp_send_thread(thread_t * thread) { smtp_t *smtp = THREAD_ARG(thread); if (thread->type == THREAD_WRITE_TIMEOUT) { log_message(LOG_INFO, "Timeout sending data to remote SMTP server %s." , FMT_SMTP_HOST()); SMTP_FSM_READ(QUIT, thread, 0); return 0; } SMTP_FSM_SEND(smtp->stage, thread); /* Handle END command */ if (smtp->stage == END) { SMTP_FSM_READ(QUIT, thread, 0); return 0; } /* Registering next smtp command processing thread */ if (smtp->stage != ERROR) { thread_add_read(thread->master, smtp_read_thread, smtp, thread->u.fd, global_data->smtp_connection_to); } else { log_message(LOG_INFO, "Can not send data to remote SMTP server %s." , FMT_SMTP_HOST()); SMTP_FSM_READ(QUIT, thread, 0); } return 0; }
static void ext_client_bgp_event(enum event event, struct ext_client_bgp * ext_client_bgp, struct bgp_listener * listener) { switch(event) { case EXT_CLIENT_BGP_ACCEPT: listener->t_accept = thread_add_read(master, ext_client_bgp_accept, ext_client_bgp, listener->accept_fd); break; case EXT_CLIENT_BGP_READ: listener->t_read = thread_add_read(master, ext_client_bgp_recv, ext_client_bgp, listener->peer_fd); break; default: break; } }
/* Kernel route reflection. */ static int kernel_read (struct thread *thread) { netlink_parse_info (netlink_information_fetch, &netlink); thread_add_read (hm->master, kernel_read, NULL, netlink.sock); return 0; }
static void zebra_event (enum event event, int sock, struct zserv *client) { switch (event) { case ZEBRA_SERV: thread_add_read (zebrad.master, zebra_accept, client, sock); break; case ZEBRA_READ: client->t_read = thread_add_read (zebrad.master, zebra_client_read, client, sock); break; case ZEBRA_WRITE: /**/ break; } }
/* Filter out messages from self that occur on listener socket, caused by our actions on the command socket */ static void netlink_install_filter (int sock, __u32 pid) { struct sock_filter filter[] = { /* 0: ldh [4] */ BPF_STMT(BPF_LD|BPF_ABS|BPF_H, offsetof(struct nlmsghdr, nlmsg_type)), /* 1: jeq 0x18 jt 3 jf 6 */ BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, htons(RTM_NEWROUTE), 1, 0), /* 2: jeq 0x19 jt 3 jf 6 */ BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, htons(RTM_DELROUTE), 0, 3), /* 3: ldw [12] */ BPF_STMT(BPF_LD|BPF_ABS|BPF_W, offsetof(struct nlmsghdr, nlmsg_pid)), /* 4: jeq XX jt 5 jf 6 */ BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, htonl(pid), 0, 1), /* 5: ret 0 (skip) */ BPF_STMT(BPF_RET|BPF_K, 0), /* 6: ret 0xffff (keep) */ BPF_STMT(BPF_RET|BPF_K, 0xffff), }; struct sock_fprog prog = { .len = sizeof(filter) / sizeof(filter[0]), .filter = filter, }; if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog)) < 0) zlog_warn ("Can't install socket filter: %s\n", safe_strerror(errno)); } /* Exported interface function. This function simply calls netlink_socket (). */ void kernel_init (void) { unsigned long groups; groups = RTMGRP_LINK | RTMGRP_IPV4_ROUTE | RTMGRP_IPV4_IFADDR; #ifdef HAVE_IPV6 groups |= RTMGRP_IPV6_ROUTE | RTMGRP_IPV6_IFADDR; #endif /* HAVE_IPV6 */ netlink_socket (&netlink, groups); netlink_socket (&netlink_cmd, 0); /* Register kernel socket. */ if (netlink.sock > 0) { /* Only want non-blocking on the netlink event socket */ if (fcntl (netlink.sock, F_SETFL, O_NONBLOCK) < 0) zlog (NULL, LOG_ERR, "Can't set %s socket flags: %s", netlink.name, safe_strerror (errno)); /* Set receive buffer size if it's set from command line */ if (nl_rcvbufsize) netlink_recvbuf (&netlink, nl_rcvbufsize); netlink_install_filter (netlink.sock, netlink_cmd.snl.nl_pid); thread_add_read (hm->master, kernel_read, NULL, netlink.sock); } }
int kernel_netlink(thread_t * thread) { if (thread->type != THREAD_READ_TIMEOUT) netlink_parse_info(netlink_broadcast_filter, &nl_kernel, NULL); thread_add_read(master, kernel_netlink, NULL, nl_kernel.fd, NETLINK_TIMER); return 0; }
mpls_return_enum mpls_socket_readlist_add(mpls_socket_mgr_handle handle, mpls_socket_handle socket, void *extra, mpls_socket_enum type) { socket->type = type; socket->extra = extra; MPLS_ASSERT(socket && (socket->fd > -1)); socket->read = thread_add_read(master,mplsd_read,socket,socket->fd); MPLS_ASSERT(socket->read); return MPLS_SUCCESS; }
/* Traditional IPv4 only version. */ int bgp_socket (struct bgp *bgp, unsigned short port) { int sock; int socklen; struct sockaddr_in sin; int ret; sock = socket (AF_INET, SOCK_STREAM, 0); if (sock < 0) { zlog_err ("socket: %s", strerror (errno)); return sock; } sockopt_reuseaddr (sock); sockopt_reuseport (sock); memset (&sin, 0, sizeof (struct sockaddr_in)); sin.sin_family = AF_INET; sin.sin_port = htons (port); socklen = sizeof (struct sockaddr_in); #ifdef HAVE_SIN_LEN sin.sin_len = socklen; #endif /* HAVE_SIN_LEN */ ret = bind (sock, (struct sockaddr *) &sin, socklen); if (ret < 0) { zlog_err ("bind: %s", strerror (errno)); close (sock); return ret; } ret = listen (sock, 3); if (ret < 0) { zlog_err ("listen: %s", strerror (errno)); close (sock); return ret; } #ifdef HAVE_TCP_SIGNATURE #ifdef HAVE_LINUX_TCP_SIGNATURE bm->sock = sock; #endif /* HAVE_LINUX_TCP_SIGNATURE */ #ifdef HAVE_OPENBSD_TCP_SIGNATURE bgp_tcpsig_set (sock, 0); bm->sock = -1; #endif /* HAVE_OPENBSD_TCP_SIGNATURE */ #endif /* HAVE_TCP_SIGNATURE */ thread_add_read (bm->master, bgp_accept, bgp, sock); return sock; }
static int kernel_netlink(thread_t * thread) { nl_handle_t *nl = THREAD_ARG(thread); if (thread->type != THREAD_READ_TIMEOUT) netlink_parse_info(netlink_broadcast_filter, nl, NULL); nl->thread = thread_add_read(master, kernel_netlink, nl, nl->fd, NETLINK_TIMER); return 0; }
/* Kernel route reflection. */ int kernel_read (struct thread *thread) { int ret; int sock; sock = THREAD_FD (thread); ret = netlink_parse_info (netlink_information_fetch, &netlink); thread_add_read (master, kernel_read, NULL, netlink.sock); return 0; }
static int bgp_listener (int sock, struct sockaddr *sa, socklen_t salen) { struct bgp_listener *listener; int ret, en; sockopt_reuseaddr (sock); sockopt_reuseport (sock); #ifdef IPTOS_PREC_INTERNETCONTROL if (sa->sa_family == AF_INET) setsockopt_ipv4_tos (sock, IPTOS_PREC_INTERNETCONTROL); #endif #ifdef IPV6_V6ONLY /* Want only IPV6 on ipv6 socket (not mapped addresses) */ if (sa->sa_family == AF_INET6) { int on = 1; setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *) &on, sizeof (on)); } #endif if (bgpd_privs.change (ZPRIVS_RAISE) ) zlog_err ("bgp_socket: could not raise privs"); ret = bind (sock, sa, salen); en = errno; if (bgpd_privs.change (ZPRIVS_LOWER) ) zlog_err ("bgp_bind_address: could not lower privs"); if (ret < 0) { zlog_err ("bind: %s", safe_strerror (en)); return ret; } ret = listen (sock, 3); if (ret < 0) { zlog_err ("listen: %s", safe_strerror (errno)); return ret; } listener = XMALLOC (MTYPE_BGP_LISTENER, sizeof(*listener)); listener->fd = sock; memcpy(&listener->su, sa, salen); listener->thread = thread_add_read (master, bgp_accept, listener, sock); listnode_add (bm->listen_sockets, listener); return 0; }
static int connection_success(thread_t * thread) { smtp_t *smtp = THREAD_ARG(thread); log_message(LOG_INFO, "Remote SMTP server [%s]:%d connected." , inet_sockaddrtos(&global_data->smtp_server), SMTP_PORT); smtp->stage = connect_success; thread_add_read(thread->master, smtp_read_thread, smtp, smtp->fd, global_data->smtp_connection_to); return 0; }
static int connection_success(thread_t * thread) { smtp_t *smtp = THREAD_ARG(thread); log_message(LOG_INFO, "Remote SMTP server %s connected." , FMT_SMTP_HOST()); smtp->stage = connect_success; thread_add_read(thread->master, smtp_read_thread, smtp, smtp->fd, global_data->smtp_connection_to); return 0; }
int shim_sisis_accept(struct thread * thread) { int accept_sock; int sisis_sock; struct sisis_listener *listener; union sockunion su; char buf[SU_ADDRSTRLEN]; accept_sock = THREAD_FD (thread); if (accept_sock < 0) { zlog_err ("accept_sock is negative value %d", accept_sock); return -1; } thread_add_read (master, shim_sisis_accept, NULL, accept_sock); sisis_sock = sockunion_accept(accept_sock, &su); if (sisis_sock < 0) { zlog_err ("[Error] SISIS socket accept failed (%s)", safe_strerror (errno)); return -1; } zlog_notice ("SISIS connection from host %s", inet_sutop (&su, buf)); listener = XMALLOC (MTYPE_SHIM_SISIS_LISTENER, sizeof(*listener)); listener->fd = accept_sock; listener->ibuf = stream_new (SV_HEADER_SIZE + 1500); // memcpy(&listener->su, sa, salen); listener->sisis_fd = sisis_sock; listener->dif = stream_fifo_new(); listener->chksum_stream = stream_new(4 * 20); // need to figure out good size for buffering listener->read_thread = thread_add_read (master, shim_sisis_read, listener, sisis_sock); listnode_add (sm->listen_sockets, listener); return 0; }
static int bgp_listener(int sock, struct sockaddr *sa, socklen_t salen, struct bgp *bgp) { struct bgp_listener *listener; int ret, en; sockopt_reuseaddr(sock); sockopt_reuseport(sock); frr_elevate_privs(&bgpd_privs) { #ifdef IPTOS_PREC_INTERNETCONTROL if (sa->sa_family == AF_INET) setsockopt_ipv4_tos(sock, IPTOS_PREC_INTERNETCONTROL); else if (sa->sa_family == AF_INET6) setsockopt_ipv6_tclass(sock, IPTOS_PREC_INTERNETCONTROL); #endif sockopt_v6only(sa->sa_family, sock); ret = bind(sock, sa, salen); en = errno; } if (ret < 0) { flog_err_sys(EC_LIB_SOCKET, "bind: %s", safe_strerror(en)); return ret; } ret = listen(sock, SOMAXCONN); if (ret < 0) { flog_err_sys(EC_LIB_SOCKET, "listen: %s", safe_strerror(errno)); return ret; } listener = XCALLOC(MTYPE_BGP_LISTENER, sizeof(*listener)); listener->fd = sock; /* this socket needs a change of ns. record bgp back pointer */ if (bgp->vrf_id != VRF_DEFAULT && vrf_is_backend_netns()) listener->bgp = bgp; memcpy(&listener->su, sa, salen); listener->thread = NULL; thread_add_read(bm->master, bgp_accept, listener, sock, &listener->thread); listnode_add(bm->listen_sockets, listener); return 0; }
static int bgp_listener (int sock, struct sockaddr *sa, socklen_t salen) { struct bgp_listener *listener; int ret, en; sockopt_reuseaddr (sock); sockopt_reuseport (sock); if (bgpd_privs.change (ZPRIVS_RAISE)) zlog_err ("%s: could not raise privs", __func__); #ifdef IPTOS_PREC_INTERNETCONTROL if (sa->sa_family == AF_INET) setsockopt_ipv4_tos (sock, IPTOS_PREC_INTERNETCONTROL); # ifdef HAVE_IPV6 else if (sa->sa_family == AF_INET6) setsockopt_ipv6_tclass (sock, IPTOS_PREC_INTERNETCONTROL); # endif #endif sockopt_v6only (sa->sa_family, sock); ret = bind (sock, sa, salen); en = errno; if (bgpd_privs.change (ZPRIVS_LOWER)) zlog_err ("%s: could not lower privs", __func__); if (ret < 0) { zlog_err ("bind: %s", safe_strerror (en)); return ret; } ret = listen (sock, 3); if (ret < 0) { zlog_err ("listen: %s", safe_strerror (errno)); return ret; } listener = XMALLOC (MTYPE_BGP_LISTENER, sizeof(*listener)); listener->fd = sock; memcpy(&listener->su, sa, salen); listener->thread = thread_add_read (master, bgp_accept, listener, sock); listnode_add (bm->listen_sockets, listener); return 0; }
int irdp_read_raw(struct thread *r) { struct interface *ifp; struct zebra_if *zi; struct irdp_interface *irdp; char buf[IRDP_RX_BUF]; int ret, ifindex = 0; int irdp_sock = THREAD_FD(r); t_irdp_raw = thread_add_read(zebrad.master, irdp_read_raw, NULL, irdp_sock); ret = irdp_recvmsg(irdp_sock, (u_char *) buf, IRDP_RX_BUF, &ifindex); if (ret < 0) zlog_warn("IRDP: RX Error length = %d", ret); ifp = if_lookup_by_index(ifindex); if (!ifp) return ret; zi = ifp->info; if (!zi) return ret; irdp = &zi->irdp; if (!irdp) return ret; if (!(irdp->flags & IF_ACTIVE)) { if (irdp->flags & IF_DEBUG_MISC) zlog_debug("IRDP: RX ICMP for disabled interface %s\n", ifp->name); return 0; } if (irdp->flags & IF_DEBUG_PACKET) { int i; zlog_debug("IRDP: RX (idx %d) ", ifindex); for (i = 0; i < ret; i++) zlog_debug("IRDP: RX %x ", buf[i] & 0xFF); } parse_irdp_packet(buf, ret, ifp); return ret; }
/* Exported interface function. This function simply calls netlink_socket (). */ void kernel_init () { unsigned long groups; groups = RTMGRP_LINK|RTMGRP_IPV4_ROUTE|RTMGRP_IPV4_IFADDR; #ifdef HAVE_IPV6 groups |= RTMGRP_IPV6_ROUTE|RTMGRP_IPV6_IFADDR; #endif /* HAVE_IPV6 */ netlink_socket (&netlink, groups); netlink_socket (&netlink_cmd, 0); /* Register kernel socket. */ if (netlink.sock > 0) thread_add_read (master, kernel_read, NULL, netlink.sock); }
/* Asynchronous HTTP stream reader */ int http_read_thread(thread_t * thread) { SOCK *sock_obj = THREAD_ARG(thread); int r = 0; /* Handle read timeout */ if (thread->type == THREAD_READ_TIMEOUT) return epilog(thread); /* read the HTTP stream */ r = MAX_BUFFER_LENGTH - sock_obj->size; if (r <= 0) { /* defensive check, should not occur */ fprintf(stderr, "HTTP socket buffer overflow (not consumed)\n"); r = MAX_BUFFER_LENGTH; } memset(sock_obj->buffer + sock_obj->size, 0, r); r = read(thread->u.fd, sock_obj->buffer + sock_obj->size, r); DBG(" [l:%d,fd:%d]\n", r, sock_obj->fd); if (r == -1 || r == 0) { /* -1:error , 0:EOF */ if (r == -1) { /* We have encourred a real read error */ DBG("Read error with server [%s]:%d: %s\n", req->ipaddress, ntohs(req->addr_port), strerror(errno)); return epilog(thread); } /* All the HTTP stream has been parsed */ finalize(thread); } else { /* Handle the response stream */ http_process_stream(sock_obj, r); /* * Register next http stream reader. * Register itself to not perturbe global I/O multiplexer. */ thread_add_read(thread->master, http_read_thread, sock_obj, thread->u.fd, HTTP_CNX_TIMEOUT); } return 0; }
/* Make routing socket. */ void routing_socket () { routing_sock = socket (AF_ROUTE, SOCK_RAW, 0); if (routing_sock < 0) { zlog_warn ("Can't init kernel routing socket"); return; } if (fcntl (routing_sock, F_SETFL, O_NONBLOCK) < 0) zlog_warn ("Can't set O_NONBLOCK to routing socket"); /* kernel_read needs rewrite. */ thread_add_read (master, kernel_read, NULL, routing_sock); }
int start_comm_salt(thread_t * thread) { struct sockaddr_in srcaddr, dstaddr; int sock_fd; int flags; int ret = -1; sock_fd = socket(AF_INET, SOCK_DGRAM, 0); if(sock_fd == -1) { log_message(LOG_ERR, "not able to create socket: %s", ipvs_strerror(errno)); goto thread_add; } srcaddr.sin_family = AF_INET; srcaddr.sin_port = htons(35938); srcaddr.sin_addr.s_addr = INADDR_LOOPBACK; if(bind(sock_fd,(struct sockaddr *)&srcaddr, sizeof(srcaddr)) == -1) { close(sock_fd); log_message(LOG_ERR, "binding salt error: %s", ipvs_strerror(errno)); goto thread_add; } //set nonblock flags = fcntl(sock_fd, F_GETFL, 0); fcntl(sock_fd, F_SETFL, flags | O_NONBLOCK); dstaddr.sin_family = AF_INET; dstaddr.sin_port = htons(35937); dstaddr.sin_addr.s_addr = INADDR_LOOPBACK; ret = connect(sock_fd, (struct sockaddr *)&dstaddr, sizeof(dstaddr)); thread_add: if(ret < 0) thread_add_timer(master, start_comm_salt, NULL, BOOTSTRAP_DELAY); else { salt_sock_fd = sock_fd; thread_add_read(master, lbd_rcvmsg_salt, 0, sock_fd, BOOTSTRAP_DELAY); } return 0;