int conn_sock(struct conn_t *conn, struct in_addr *addr, int port) {
struct sockaddr_in server;
int sock;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(port);
server.sin_addr.s_addr = addr->s_addr;
if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) > 0) {
#if(_debug_)
/*log_dbg("SETTING non-blocking");*/
#endif
if (ndelay_on(sock) < 0) {
log_err(errno, "could not set non-blocking");
}
if (safe_connect(sock,
(struct sockaddr *) &server,
sizeof(server)) < 0) {
if (errno != EINPROGRESS) {
log_err(errno, "could not connect to %s:%d",
inet_ntoa(server.sin_addr), port);
close(sock);
return -1;
}
}
}
conn->sock = sock;
return 0;
}
static int
sock_redir_getstate(struct redir_t *redir,
struct sockaddr_in *address,
struct sockaddr_in *baddress,
struct redir_conn_t *conn) {
struct redir_msg_t msg;
struct sockaddr_un remote;
size_t len = sizeof(remote);
int s;
char filedest[512];
statedir_file(filedest, sizeof(filedest), _options.unixipc, "chilli.ipc");
memset(&msg, 0, sizeof(msg));
msg.mtype = REDIR_MSG_STATUS_TYPE;
memcpy(&msg.mdata.address, address, sizeof(msg.mdata.address));
memcpy(&msg.mdata.baddress, baddress, sizeof(msg.mdata.baddress));
if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
log_err(errno, "socket()");
return -1;
}
memset(&remote, 0, sizeof(remote));
remote.sun_family = AF_UNIX;
strcpy(remote.sun_path, filedest);
#if defined (__FreeBSD__) || defined (__APPLE__) || defined (__OpenBSD__)
remote.sun_len = strlen(remote.sun_path) + 1;
#endif
len = offsetof(struct sockaddr_un, sun_path) + strlen(remote.sun_path);
if (safe_connect(s, (struct sockaddr *)&remote, len) == -1) {
log_err(errno, "could not connect to %s", remote.sun_path);
close(s);
return -1;
}
if (safe_write(s, &msg, sizeof(msg)) != sizeof(msg)) {
log_err(errno, "could not write to %s", remote.sun_path);
close(s);
return -1;
}
if (safe_read(s, conn, sizeof(*conn)) != sizeof(*conn)) {
log_warn(0, "no session available from %s", remote.sun_path);
close(s);
return -1;
}
close(s);
return conn->s_state.authenticated == 1;
}
/* need to connect() to get a socket */
bool sbuf_connect(SBuf *sbuf, const struct sockaddr *sa, int sa_len, int timeout_sec)
{
int res, sock;
struct timeval timeout;
bool is_unix = sa->sa_family == AF_UNIX;
Assert(iobuf_empty(sbuf->io) && sbuf->sock == 0);
AssertSanity(sbuf);
/*
* common stuff
*/
sock = socket(sa->sa_family, SOCK_STREAM, 0);
if (sock < 0) {
/* probably fd limit */
goto failed;
}
if (!tune_socket(sock, is_unix))
goto failed;
sbuf->sock = sock;
timeout.tv_sec = timeout_sec;
timeout.tv_usec = 0;
/* launch connection */
res = safe_connect(sock, sa, sa_len);
if (res == 0) {
/* unix socket gives connection immediately */
sbuf_connect_cb(sock, EV_WRITE, sbuf);
return true;
} else if (errno == EINPROGRESS) {
/* tcp socket needs waiting */
event_set(&sbuf->ev, sock, EV_WRITE, sbuf_connect_cb, sbuf);
res = event_add(&sbuf->ev, &timeout);
if (res >= 0) {
sbuf->wait_type = W_CONNECT;
return true;
}
}
failed:
log_warning("sbuf_connect failed: %s", strerror(errno));
if (sock >= 0)
safe_close(sock);
sbuf->sock = 0;
sbuf_call_proto(sbuf, SBUF_EV_CONNECT_FAILED);
return false;
}
int main()
{
int sd = safe_socket_tcp();
struct sockaddr_in adress;
adress.sin_family = AF_INET;
adress.sin_port = htons(PORT);
adress.sin_addr.s_addr = INADDR_ANY; // bind to all ips
safe_connect(sd, &adress);
printf("Sent connection\n");
char buffer[MAX_BUFFER];
read_string(sd, buffer);
printf("got string from server: %s\n", buffer);
safe_close(sd);
return 0;
}
