int service_connect(struct service * svc, struct thread * connecting_thread,
struct socket ** client_socket, bool * blocking)
{
*blocking = false;
*client_socket = 0;
if(svc->listening_thread != 0)
{
struct socket * server_socket = socket_create(svc->listening_thread);
*client_socket = socket_create(connecting_thread);
socket_connect(*client_socket, server_socket);
// Wake up the listening thread and return the new socket:
mordax_resource_t server_retval = process_add_resource(svc->listening_thread->parent,
PROCESS_RESOURCE_SOCKET, server_socket);
context_set_syscall_retval(svc->listening_thread->context, (void *) server_retval);
scheduler_move_thread_to_running(svc->listening_thread);
svc->listening_thread = 0;
return 0;
} else {
queue_add_back(svc->backlog, connecting_thread);
*blocking = true;
return 0;
}
}
int service_listen(struct service * svc, struct thread * listener,
struct socket ** server_socket, bool * blocking)
{
*blocking = false;
*server_socket = 0;
if(svc->listening_thread != 0)
return -EBUSY;
if(svc->backlog->elements > 0)
{
struct thread * client_thread = 0;
if(!queue_remove_front(svc->backlog, (void **) &client_thread))
return -EINTERNAL;
struct socket * client_socket = socket_create(client_thread);
*server_socket = socket_create(listener);
socket_connect(client_socket, *server_socket);
mordax_resource_t client_retval = process_add_resource(client_thread->parent,
PROCESS_RESOURCE_SOCKET, client_socket);
context_set_syscall_retval(client_thread->context, (void *) client_retval);
scheduler_move_thread_to_running(client_thread);
return 0;
} else {
svc->listening_thread = listener;
*blocking = true;
return 0;
}
}
/*
* Kernel Sockets
*
* Mostly a wrapper around the private socket_* functions.
*/
int
ksocket_socket(ksocket_t *ksp, int domain, int type, int protocol, int flags,
struct cred *cr)
{
static const int version = SOV_DEFAULT;
int error = 0;
struct sonode *so;
*ksp = NULL;
/* All Solaris components should pass a cred for this operation. */
ASSERT(cr != NULL);
if (domain == AF_NCA || domain == AF_UNIX)
return (EAFNOSUPPORT);
ASSERT(flags == KSOCKET_SLEEP || flags == KSOCKET_NOSLEEP);
so = socket_create(domain, type, protocol, NULL, NULL, version, flags,
cr, &error);
if (so == NULL) {
if (error == EAFNOSUPPORT) {
char *mod = NULL;
/*
* Could be that root file sytem is not loaded or
* soconfig has not run yet.
*/
if (type == SOCK_STREAM && (domain == AF_INET ||
domain == AF_INET6) && (protocol == 0 ||
protocol == IPPROTO_TCP)) {
mod = SOCKETMOD_TCP;
} else if (type == SOCK_DGRAM && (domain == AF_INET ||
domain == AF_INET6) && (protocol == 0 ||
protocol == IPPROTO_UDP)) {
mod = SOCKETMOD_UDP;
} else {
return (EAFNOSUPPORT);
}
so = socket_create(domain, type, protocol, NULL,
mod, version, flags, cr, &error);
if (so == NULL)
return (error);
} else {
return (error);
}
}
so->so_mode |= SM_KERNEL;
*ksp = SOTOKS(so);
return (0);
}
int nettest1(void)
{
int err;
sockaddr addr;
fd = socket_create(SOCK_PROTO_TCP, 0);
printf("created socket, fd %d\n", fd);
if(fd < 0)
return 0;
memset(&addr, 0, sizeof(addr));
addr.addr.len = 4;
addr.addr.type = ADDR_TYPE_IP;
// addr.port = 19;
// NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(63,203,215,73);
// addr.port = 23;
// NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(192,168,0,3);
addr.port = 6667;
NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(209,131,227,242);
err = socket_connect(fd, &addr);
printf("socket_connect returns %d\n", err);
if(err < 0)
return err;
exit_sem = _kern_sem_create(0, "exit");
_kern_thread_resume_thread(_kern_thread_create_thread("read_thread", &read_thread, NULL));
_kern_thread_resume_thread(_kern_thread_create_thread("write_thread", &write_thread, NULL));
for(;;)
_kern_sem_acquire(exit_sem, 1);
return 0;
}
int nettest4(void)
{
int err;
sockaddr addr;
fd = socket_create(SOCK_PROTO_TCP, 0);
printf("created socket, fd %d\n", fd);
if(fd < 0)
return 0;
memset(&addr, 0, sizeof(addr));
addr.addr.len = 4;
addr.addr.type = ADDR_TYPE_IP;
addr.port = 1900;
NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(63,203,215,73);
err = socket_connect(fd, &addr);
printf("socket_connect returns %d\n", err);
if(err < 0)
return err;
usleep(5000000);
err = socket_close(fd);
printf("socket_close returns %d\n", err);
return 0;
}
// sets errno on error
int websocket_create(Websocket *websocket) {
int rc = socket_create(&websocket->base);
if (rc < 0) {
return rc;
}
websocket->base.base.type = "WebSocket";
websocket->base.destroy = websocket_destroy;
websocket->base.receive = websocket_receive;
websocket->base.send = websocket_send;
websocket->frame_index = 0;
websocket->line_index = 0;
websocket->state = WEBSOCKET_STATE_WAIT_FOR_HANDSHAKE;
memset(&websocket->frame, 0, sizeof(WebsocketFrame));
memset(websocket->line, 0, WEBSOCKET_MAX_LINE_LENGTH);
memset(websocket->client_key, 0, WEBSOCKET_CLIENT_KEY_LENGTH);
if (queue_create(&websocket->send_queue, sizeof(WebsocketQueuedData)) < 0) {
return -1;
}
return 0;
}
int main(int arg, char *args[])
{
sql_connect(&mysql, &conn);
//如果没有参数，main函数返回
if(arg < 2)
{
printf("usage:myserver port\n");
return EXIT_FAILURE;
}
//setdaemon();
//将第一个参数转化为整数
int iport = atoi(args[1]);
if(iport == 0)
{
printf("port %d is invalid\n", iport);
return EXIT_FAILURE;
}
int st = socket_create(iport);
socket_accept(st);
sql_disconnect(conn);
close(st);
printf("myhttp is end\n");
return 0;
}
/*
initialise a wrepl_socket. The event_ctx is optional, if provided then
operations will use that event context
*/
struct wrepl_socket *wrepl_socket_init(TALLOC_CTX *mem_ctx,
struct tevent_context *event_ctx,
struct smb_iconv_convenience *iconv_convenience)
{
struct wrepl_socket *wrepl_socket;
NTSTATUS status;
wrepl_socket = talloc_zero(mem_ctx, struct wrepl_socket);
if (!wrepl_socket) return NULL;
wrepl_socket->event.ctx = talloc_reference(wrepl_socket, event_ctx);
if (!wrepl_socket->event.ctx) goto failed;
wrepl_socket->iconv_convenience = iconv_convenience;
status = socket_create("ip", SOCKET_TYPE_STREAM, &wrepl_socket->sock, 0);
if (!NT_STATUS_IS_OK(status)) goto failed;
talloc_steal(wrepl_socket, wrepl_socket->sock);
wrepl_socket->request_timeout = WREPL_SOCKET_REQUEST_TIMEOUT;
talloc_set_destructor(wrepl_socket, wrepl_socket_destructor);
return wrepl_socket;
failed:
talloc_free(wrepl_socket);
return NULL;
}
/*
* Initialize CMWHOD
*/
void
create()
{
int error;
rm(LOG_DIR + "/cmwhod");
log_info(CLIENT_VERSION + ": cmwhod log for '" + THIS_MUD + "'\n");
socket = socket_create(DATAGRAM, "read", "close");
if (socket < 0) {
log_info("socket_create: " + socket_error(socket) + "\n");
return;
}
error = socket_bind(socket, 0);
if (error != EESUCCESS) {
log_info("socket_bind: " + socket_error(error) + "\n");
return;
}
set_comments();
mwhod_addr = DAEMON_IP + " " + UDP_PORT;
mudname = capitalize(THIS_MUD);
set_keepalive_message();
set_boot_message();
call_out("keepalive", KEEPALIVE_INTERVAL);
call_out("refresh", REFRESH_INTERVAL / PARTITIONS, 0);
}
int nettest2(void)
{
int err;
sockaddr addr;
fd = socket_create(SOCK_PROTO_TCP, 0);
printf("created socket, fd %d\n", fd);
if(fd < 0)
return 0;
memset(&addr, 0, sizeof(addr));
addr.addr.len = 4;
addr.addr.type = ADDR_TYPE_IP;
addr.port = 9;
NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(63,203,215,73);
err = socket_connect(fd, &addr);
printf("socket_connect returns %d\n", err);
if(err < 0)
return err;
for(;;) {
char buf[4096];
socket_write(fd, buf, sizeof(buf));
}
return 0;
}
virtual bool initSocket() {
if (socket==SOCKET_INVALID) {
socket = socket_create(AF_INET, SOCK_STREAM, IPPROTO_TCP, 54, 0);
sockaddr_t socketAddr;
int testResult = 0;
// the family is always AF_INET
socketAddr.sa_family = AF_INET;
socketAddr.sa_data[0] = 0;
socketAddr.sa_data[1] = 54;
// the destination IP address: 8.8.8.8
socketAddr.sa_data[2] = 127;
socketAddr.sa_data[3] = 0;
socketAddr.sa_data[4] = 0;
socketAddr.sa_data[5] = 1;
testResult = socket_connect(socket, &socketAddr, sizeof(socketAddr));
if (testResult) {
socket_close(socket);
socket = SOCKET_INVALID;
}
}
return socket!=SOCKET_INVALID;
}
/* To establish a SOCKS5 connection, we create 2 idx's: one for the caller, and
one that we use to connect to the server. */
int socks5_connect(int idx, char *proxy_host, int proxy_port, char *username, char *password, char *dest_host, int dest_port)
{
int sock;
proxy_info_t *info;
sock = socket_create(proxy_host, proxy_port, NULL, 0, SOCKET_CLIENT|SOCKET_TCP|SOCKET_NONBLOCK);
if (sock < 0) return(-1);
info = (proxy_info_t *)malloc(sizeof(*info));
info->host = strdup(dest_host);
info->port = dest_port;
if (!username) username = "";
if (!password) password = "";
info->username = strdup(username);
info->password = strdup(password);
info->status = 0;
info->our_idx = sockbuf_new();
sockbuf_set_sock(info->our_idx, sock, SOCKBUF_CLIENT);
if (idx >= 0) info->their_idx = idx;
else info->their_idx = sockbuf_new();
info->sock = sock;
sockbuf_set_handler(info->our_idx, &socks5_events, info);
return(info->their_idx);
}
work::work(int port) //
{
memset(socket_client, 0, sizeof(socket_client));
listen_st = socket_create(port);//创建server端socket
if (listen_st == 0)
exit(-1);//创建socket失败，程序退出
}
int netlink_init() {
struct socket *socket;
// Регистрируем протокол
if(register_routing_protocol(&system_proto) < 0) {
error("Unable to register System routing protocol");
return -1;
}
if((socket = socket_create(&system_proto)) == NULL) {
error("Unable to create Netlink socket");
return -1;
}
if(socket_bind_to_netlink(socket) < 0) {
error("Unable to bind socket to Netlink");
return -1;
}
if(socketlist_add(socket) < 0) {
error("Unable to register Netlink socket");
return -1;
}
return 0;
}
/**
* Test the connection and protocol
*/
static void check_connection(Service_T s, Port_T p) {
Socket_T socket;
volatile int rv = TRUE;
char buf[STRLEN];
char report[STRLEN] = {0};
struct timeval t1;
struct timeval t2;
ASSERT(s && p);
/* Get time of connection attempt beginning */
gettimeofday(&t1, NULL);
/* Open a socket to the destination INET[hostname:port] or UNIX[pathname] */
socket = socket_create(p);
if (!socket) {
snprintf(report, STRLEN, "failed, cannot open a connection to %s", Util_portDescription(p, buf, sizeof(buf)));
rv = FALSE;
goto error;
} else
DEBUG("'%s' succeeded connecting to %s\n", s->name, Util_portDescription(p, buf, sizeof(buf)));
/* Verify that the socket is ready for i|o. TCP sockets are checked anytime, UDP
* sockets just when there is no specific protocol test used since the socket_is_ready()
* adds 2s delay when used with UDP socket. When there is specific protocol used, we
* don't need it for UDP, since the protocol test is sufficient */
if ((socket_get_type(socket) != SOCK_DGRAM || p->protocol->check == check_default) && !socket_is_ready(socket)) {
snprintf(report, STRLEN, "connection failed, %s is not ready for i|o -- %s", Util_portDescription(p, buf, sizeof(buf)), STRERROR);
rv = FALSE;
goto error;
}
/* Run the protocol verification routine through the socket */
if (! p->protocol->check(socket)) {
snprintf(report, STRLEN, "failed protocol test [%s] at %s", p->protocol->name, Util_portDescription(p, buf, sizeof(buf)));
rv = FALSE;
goto error;
} else
DEBUG("'%s' succeeded testing protocol [%s] at %s\n", s->name, p->protocol->name, Util_portDescription(p, buf, sizeof(buf)));
/* Get time of connection attempt finish */
gettimeofday(&t2, NULL);
/* Get the response time */
p->response = (double)(t2.tv_sec - t1.tv_sec) + (double)(t2.tv_usec - t1.tv_usec)/1000000;
error:
if (socket)
socket_free(&socket);
if (!rv) {
p->response = -1;
p->is_available = FALSE;
Event_post(s, Event_Connection, STATE_FAILED, p->action, report);
} else {
p->is_available = TRUE;
Event_post(s, Event_Connection, STATE_SUCCEEDED, p->action, "connection succeeded to %s", Util_portDescription(p, buf, sizeof(buf)));
}
}
int main(int argc, char **argv)
{
int mysock = -1;
if (argc != 3) {
printf("usage: %s LOCAL_TCP_PORT DEVICE_TCP_PORT\n", argv[0]);
return 0;
}
listen_port = atoi(argv[1]);
device_port = atoi(argv[2]);
if (!listen_port) {
fprintf(stderr, "Invalid listen_port specified!\n");
return -EINVAL;
}
if (!device_port) {
fprintf(stderr, "Invalid device_port specified!\n");
return -EINVAL;
}
// first create the listening socket endpoint waiting for connections.
mysock = socket_create(listen_port);
if (mysock < 0) {
fprintf(stderr, "Error creating socket: %s\n", strerror(errno));
return -errno;
} else {
#ifdef WIN32
HANDLE acceptor = NULL;
#else
pthread_t acceptor;
#endif
struct sockaddr_in c_addr;
socklen_t len = sizeof(struct sockaddr_in);
struct client_data cdata;
int c_sock;
while (1) {
printf("waiting for connection\n");
c_sock = accept(mysock, (struct sockaddr*)&c_addr, &len);
if (c_sock) {
printf("accepted connection, fd = %d\n", c_sock);
cdata.fd = c_sock;
#ifdef WIN32
acceptor = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)acceptor_thread, &cdata, 0, NULL);
WaitForSingleObject(acceptor, INFINITE);
#else
pthread_create(&acceptor, NULL, acceptor_thread, &cdata);
pthread_join(acceptor, NULL);
#endif
} else {
break;
}
}
close(c_sock);
close(mysock);
}
return 0;
}
status_t
socket_spawn_pending(net_socket *_parent, net_socket **_socket)
{
net_socket_private *parent = (net_socket_private *)_parent;
MutexLocker locker(parent->lock);
// We actually accept more pending connections to compensate for those
// that never complete, and also make sure at least a single connection
// can always be accepted
if (parent->child_count > 3 * parent->max_backlog / 2)
return ENOBUFS;
net_socket_private *socket;
status_t status = socket_create(parent->family, parent->type, parent->protocol,
(net_socket **)&socket);
if (status < B_OK)
return status;
// inherit parent's properties
socket->send = parent->send;
socket->receive = parent->receive;
socket->options = parent->options & ~SO_ACCEPTCONN;
socket->linger = parent->linger;
memcpy(&socket->address, &parent->address, parent->address.ss_len);
memcpy(&socket->peer, &parent->peer, parent->peer.ss_len);
// add to the parent's list of pending connections
list_add_item(&parent->pending_children, socket);
socket->parent = parent;
parent->child_count++;
*_socket = socket;
return B_OK;
}
/**
* @brief udp broadcast recv data
*
* @param cast_ip [in] ip address of broadcast
* @param port [in] port of broadcast
* @param cast_times [in] broadcast times
* @param cast_info [out] broadcast data
* @param size [in] size of broadcast data
*
* @return 0, if succ; -1, if failed.
*/
int udp_broadcast_recv(const char *cast_ip, int port, int cast_times,\
char *cast_info, int size)
{
int fd = -1;
struct sockaddr_in addr = {0};
if (cast_times < 1) return -1;
/**
* 1. socket create and init
* 2. set socket broadcast
* 3. bind socket
*/
fd = socket_create(AF_INET, SOCK_DGRAM);
inet_addr_init(&addr, cast_ip, port);
make_socket_broadcast(fd, 1);
socket_bind(fd, (struct sockaddr *)&addr);
/**
* recv broadcast data cycly
*/
while (cast_times-- > 0)
{
if (socket_addr_recvfrom(fd, cast_info, \
size, &addr) > 0)
printf("broadcast recv from %s: %s\n", \
inet_ntoa(addr.sin_addr), cast_info);
}
socket_close(fd);
return 0;
}
static void run_networking_test(bool server)
{
if (!server) {
connection_t *conn = connection_create(&on_connect);
if (!conn)
return;
printf("connecting to localhost on port 1337\n");
socket_connect(conn, "127.0.0.1", "1337");
char buffer[1024];
while (fgets(buffer, sizeof buffer, stdin))
socket_write(conn, buffer);
} else {
socket_t *sock = socket_create(on_accept);
if (!sock)
return;
printf("Server will bind to port 1337.\n");
socket_listen(sock, NULL, 1337, 10);
while (1) {
sleep(5);
printf("%d connections ATM\n", sock->num_connections);
}
}
}
/**
* @brief udp broadcast send data
*
* @param cast_ip [in] ip address of broadcast
* @param port [in] port of broadcast
* @param cast_times [in] broadcast times
* @param cast_info [in] broadcast data
*
* @return 0, if succ; -1, if failed.
*/
int udp_broadcast_send(const char *cast_ip, int port, int cast_times,\
const char *cast_info)
{
int fd = -1;
struct sockaddr_in addr = {0};
if (cast_times < 1) return -1;
/**
* 1. socket create and init
* 2. set socket broadcast
*/
fd = socket_create(AF_INET, SOCK_DGRAM);
inet_addr_init(&addr, cast_ip, port);
make_socket_broadcast(fd, 1);
/**
* send broadcast data cycly
*/
while (cast_times-- > 0)
{
socket_addr_sendto(fd, (void *)cast_info, strlen(cast_info), &addr);
sleep(1);
}
socket_close(fd);
return 0;
}
/*
initialise a nbt_dgram_socket. The event_ctx is optional, if provided
then operations will use that event context
*/
struct nbt_dgram_socket *nbt_dgram_socket_init(TALLOC_CTX *mem_ctx,
struct tevent_context *event_ctx)
{
struct nbt_dgram_socket *dgmsock;
NTSTATUS status;
dgmsock = talloc(mem_ctx, struct nbt_dgram_socket);
if (dgmsock == NULL) goto failed;
dgmsock->event_ctx = event_ctx;
if (dgmsock->event_ctx == NULL) goto failed;
status = socket_create("ip", SOCKET_TYPE_DGRAM, &dgmsock->sock, 0);
if (!NT_STATUS_IS_OK(status)) goto failed;
socket_set_option(dgmsock->sock, "SO_BROADCAST", "1");
talloc_steal(dgmsock, dgmsock->sock);
dgmsock->fde = tevent_add_fd(dgmsock->event_ctx, dgmsock,
socket_get_fd(dgmsock->sock), 0,
dgm_socket_handler, dgmsock);
dgmsock->send_queue = NULL;
dgmsock->incoming.handler = NULL;
dgmsock->mailslot_handlers = NULL;
return dgmsock;
failed:
talloc_free(dgmsock);
return NULL;
}
bool socketer::listen(unsigned short port, int backlog, bool islocal)
{
struct sockaddr_in soaddr;
if(m_sockfd != NET_INVALID_SOCKET)
close();
m_sockfd = socket_create();
if(m_sockfd == NET_INVALID_SOCKET)
return false;
memset(&soaddr, 0, sizeof(soaddr));
soaddr.sin_family = AF_INET;
if(islocal)
soaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
else
soaddr.sin_addr.s_addr - INADDR_ANY;
soaddr.sin_port = htons(port);
if(bind(m_sockfd, (struct sockaddr *)&soaddr, sizeof(soaddr)) !=0)
{
close();
return false;
}
if(listen(m_sockfd, backlog) != 0)
{
close();
return false;
}
return true;
}
static int tcp_sock_finish_setup(tcp_sockdata_t *sock, int *sock_id)
{
socket_core_t *sock_core;
int rc;
log_msg(LVL_DEBUG, "tcp_sock_finish_setup()");
sock->recv_fibril = fibril_create(tcp_sock_recv_fibril, sock);
if (sock->recv_fibril == 0)
return ENOMEM;
rc = socket_create(&sock->client->sockets, sock->client->sess,
sock, sock_id);
if (rc != EOK) {
fibril_destroy(sock->recv_fibril);
sock->recv_fibril = 0;
return rc;
}
sock_core = socket_cores_find(&sock->client->sockets, *sock_id);
assert(sock_core != NULL);
sock->sock_core = sock_core;
return EOK;
}
void initConnection() {
int fd;
fd = socket_create(STREAM, "socket_readcallback", "listenClose");
socket_bind(fd, 12333);
socket_listen(fd, "listenInbound");
}
int main(void)
{
WSADATA Data;
SOCKADDR_IN recvSockAddr;
SOCKET recvSocket;
struct hostent * remoteHost;
char * ip;
const char * host_name = "pb-homework.appspot.com";
char maxBuff[MAXBUFLEN] = "\0";
int status = initDLL(Data);
if(status == 1)
{
fprintf(stderr, "Cannot initialize dll - WSAStartup failed.");
exit(1);
}
remoteHost = gethostbyname(host_name);
ip = inet_ntoa(*(struct in_addr *)*remoteHost->h_addr_list);
memset(&recvSockAddr, 0, sizeof(recvSockAddr));
recvSockAddr.sin_port=htons(PORT);
recvSockAddr.sin_family=AF_INET;
recvSockAddr.sin_addr.s_addr= inet_addr(ip);
recvSocket = socket_create();
socket_connect(recvSocket, recvSockAddr);
socket_sendRequest(host_name, recvSocket);
socket_receiveInfo(recvSocket, maxBuff);
getSecret(maxBuff, host_name, recvSocket);
socket_receiveInfo(recvSocket, maxBuff);
printf("******************************************\n"
"Answer to request from R.A. server\n"
"%s\n"
"******************************************\n",
maxBuff);
// Find the longest word here!
char longest[80] = "\0";
longestWord(maxBuff, longest);
printf("\n\n******************************************\n"
"Longest word was: [%s]\n"
"******************************************\n",
longest);
socket_sendPost(recvSocket, host_name, longest);
socket_receiveInfo(recvSocket, maxBuff);
printf("\n\n******************************************\n"
"Answer from R.A. server to my POST:\n"
"%s\n"
"******************************************\n",
maxBuff);
// Close all sockets.
closesocket(recvSocket);
// Free memory associated with sockets.
WSACleanup();
return 0;
}
void consume_all_sockets(uint8_t protocol)
{
static int port = 9000;
int socket_handle;
do {
socket_handle = socket_create(AF_INET, SOCK_STREAM, protocol==IPPROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP, port++, NIF_DEFAULT);
} while(socket_handle_valid(socket_handle));
}
t_socket* socket_listen_in(char* ip, int port) {
t_socket* sock = socket_create();
addr_info* addr = addr_create(ip, port);
bind(sock->socket, (struct sockaddr*) addr, sizeof(addr_info));
listen(sock->socket, 100);
free(addr);
return sock;
}
t_socket* socket_connect_to(char* ip, int port) {
t_socket* sock = socket_create();
addr_info* addr = addr_create(ip, port);
connect(sock->socket, (struct sockaddr*) addr, sizeof(addr_info));
free(addr);
return sock;
}
/*************************************************************************
* FUNCTION
* custom_socket_create
*
* DESCRIPTION
* Customize SOCKET create function.
* Return KAL_FALSE directly if SOCKET should not be created.
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_bool custom_socket_create(comptask_handler_struct **handle)
{
#ifdef SOC_NOT_PRESENT
return KAL_FALSE;
#else
return socket_create(handle);
#endif /* SOC_NOT_PRESENT */
}
/*-------------------------------------------------------------------------*\
* Tries to create a new inet socket
\*-------------------------------------------------------------------------*/
const char *inet_trycreate(p_socket ps, int family, int type, int protocol) {
const char *err = socket_strerror(socket_create(ps, family, type, protocol));
if (err == NULL && family == AF_INET6) {
int yes = 1;
setsockopt(*ps, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&yes, sizeof(yes));
}
return err;
}
