/***************************************************************************************** 函数名称: dpd_timeout 功能描述: dpd超时处理,删除连接 输入参数: st 输出参数: 无 返 回 值: 无 ------------------------------------------------------------------------------------------- 最近一次修改记录 : 修改作者: 王之云 修改目的: 超时处理 修改日期: 2012年3月20日 ********************************************************************************************/ void dpd_timeout(struct state *st) { int action; struct ike_conn *c = st->st_connection; action = st->st_connection->dpd_action; so_serial_t newest = c->newest_isakmp_sa ; char buf_remoteip[20] = {0}; st->st_dpd_timeout_flag = 1; addrtot(&st->st_remoteaddr, 0, buf_remoteip, sizeof(buf_remoteip)); passert(IS_ISAKMP_SA_ESTABLISHED(st->st_state)); passert(action == DPD_ACTION_HOLD || action == DPD_ACTION_CLEAR || action == DPD_ACTION_RESTART || action == DPD_ACTION_RESTART_BY_PEER); if (newest != st->st_serialno && newest != SOS_NOBODY) { IPSEC_log(IPSEC_LOGLEVEL_WARNING, "Connection < %s > < %s > old state DPD TIMEOUT, " "We will delete state depend on it.!", st->st_connection->name, buf_remoteip); ipsec_release_state_by_parent(st); delete_state(st); return; } { IPSEC_log(IPSEC_LOGLEVEL_WARNING, "Connection < %s > < %s > DPD TIMEOUT, we will %s connection!", st->st_connection->name, buf_remoteip, action == DPD_ACTION_CLEAR ? "clear":"restart"); } switch(action) { case DPD_ACTION_CLEAR: release_connection(&c); break; case DPD_ACTION_RESTART: release_connection(&c); if(NULL != c) { start_initiate_connnection(c); } break; case DPD_ACTION_HOLD: case DPD_ACTION_RESTART_BY_PEER: /*未用到此两种情况*/ break; default : break; } }
/* {{{ proto void Riak\Bucket->getKeyStream(Riak\Output\KeyStreamOutput streamer [, int $timeout = 0]) Streams all keys in the bucket */ PHP_METHOD(RiakBucket, getKeyStream) { struct riak_stream_key_cb_param cb_params; riack_string rsbucket, *rstype; riak_connection *connection, *stream_connection; zval* zstreamer; long timeout; int riackstatus; timeout = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|l", &zstreamer, riak_key_streamer_ce, &timeout) == FAILURE) { zend_throw_exception(riak_badarguments_exception_ce, "Bad or missing argument", 500 TSRMLS_CC); return; } // Create a new connection only for this stream // LibRiack can only handle one operation at the time pr connection connection = get_riak_connection(getThis() TSRMLS_CC); THROW_EXCEPTION_IF_CONNECTION_IS_NULL(connection); stream_connection = take_connection(connection->client->host, strlen(connection->client->host), connection->client->port TSRMLS_CC); if (!stream_connection) { CHECK_RIACK_STATUS_THROW_AND_RETURN_ON_ERROR(stream_connection, RIACK_ERROR_COMMUNICATION); } rsbucket = riack_name_from_bucket(getThis() TSRMLS_CC); #ifdef ZTS cb_params.tsrm_ls = TSRMLS_C; #endif cb_params.zstreamer = zstreamer; rstype = riack_get_bucket_type_from_bucket(connection->client, getThis() TSRMLS_CC); // Not gonna do a retry here on purpose... no reason to retry a mistake in the first place riackstatus = riack_stream_keys_ext(stream_connection->client, &rsbucket, rstype, riak_stream_key_cb, &cb_params, timeout); CHECK_RIACK_STATUS_THROW_ON_ERROR(stream_connection, riackstatus); RFREE(connection->client, rstype); release_connection(stream_connection TSRMLS_CC); }
void handle_terminated_fork_client(fd_set *rdset) { int i, ret; char buf[2]; for (i = 0; i < MAX_FDS; i++) { if (connection_info[i].pid && connection_info[i].fd >= 0 && FD_ISSET(connection_info[i].fd, rdset)) { ret = read(connection_info[i].fd, buf, sizeof(buf)); if (ret == 0 || (ret == -1 && errno == ECONNRESET)) { close(connection_info[i].fd); release_connection(i); } else { fprintf(stderr, "Unexpected read on fork-server connection: %d(%s)\n", ret, strerror(errno)); close(connection_info[i].fd); release_connection(i); } } } }
int mpi2bsp(char* input, void* input_data, int in_length, void* output, int out_length, int binary) { int sockfd = get_connection(POOL, "127.0.0.1", LOCAL_PORT); if (sockfd < 0) { printf("Failed to open a socket to the parent process\n"); exit(1); } send(sockfd, input, strlen(input), 0); if (in_length > 0) { send(sockfd, input_data, in_length, 0); } int bytes_read = 0; if (binary) { char temp[4]; while (bytes_read < 4) { int ret = recv(sockfd, &temp[bytes_read], 4 - bytes_read, 0); if (ret <= 0) { exit(1); } else { bytes_read += ret; } } int* actual_length = (int*) &temp; bytes_read = 0; while (bytes_read < *actual_length) { int ret = recv(sockfd, output + bytes_read, *actual_length - bytes_read, 0); if (ret <= 0) { exit(1); } else { bytes_read += ret; } } } else { while (bytes_read < out_length) { int ret = recv(sockfd, output + bytes_read, out_length - bytes_read, 0); if (ret <= 0) { exit(1); } else { bytes_read += ret; char* char_output = (char*) output; if (char_output[bytes_read - 1] == 0) { break; } } } } release_connection(POOL, "127.0.0.1", LOCAL_PORT, sockfd); return bytes_read; }
static int mapistore_namedprops_mysql_destructor(struct namedprops_context *self) { DEBUG(5, ("[%s:%d] Destroying namedprops mysql context\n", __FUNCTION__, __LINE__)); if (self && self->data) { MYSQL *conn = self->data; release_connection(conn); } else { DEBUG(0, ("[%s:%d] Error: tried to destroy corrupted namedprops mysql context\n", __FUNCTION__, __LINE__)); } return 0; }
void reap_children() { int status; int pid; int id; while ((pid = waitpid(-1, &status, WNOHANG)) > 0) { id = find_connection(pid); if (id < 0) continue; release_connection(id); } child_exited = 0; }
int MPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype type, MPI_Op op, int root, MPI_Comm comm) { if (!INITIALIZED) { exit(1); } char input[128]; char output[8]; int size = count * mpi_sizeof(type); if (MPI_RANK != root) { sprintf(input, "MPI_Reduce\ncount=%d\nsource=%d\ndest=%d\ncomm=%d\ntype=%d\n\n", size, root, root, comm, type); mpi2bsp(input, sendbuf, size, output, 8, FALSE); } else { if (sendbuf == recvbuf) { exit(1); } else if (sendbuf != MPI_IN_PLACE) { memcpy(recvbuf, sendbuf, size); } sprintf(input, "MPI_Reduce\nrcount=%d\nsource=%d\ncomm=%d\ntype=%d\n\n", size, root, comm, type); int sockfd = get_connection(POOL, "127.0.0.1", LOCAL_PORT); if (sockfd < 0) { printf("Failed to open a socket to the parent process\n"); exit(1); } send(sockfd, input, strlen(input), 0); int i; void* temp = malloc(size); for (i = 0; i < MPI_SIZE - 1; i++) { int bytes_read = 0; while (bytes_read < size) { int ret = recv(sockfd, temp + bytes_read, size - bytes_read, 0); if (ret <= 0) { exit(1); } else { bytes_read += ret; } } mpi_reduce(recvbuf, temp, count, type, op); } release_connection(POOL, "127.0.0.1", LOCAL_PORT, sockfd); free(temp); } return 0; }
static int redirect(struct connection *conn, int status) { char *p = strstr(conn->buf, "Location:"); if (p) { char *e; for (p += 9; isspace(*p); ++p) ; e = strchr(p, '\n'); if (e) { while (isspace(*(e - 1))) --e; *e = '\0'; if (!conn->redirect_ok || verbose > 1) printf("WARNING: %s redirected to %s\n", conn->url, p); release_connection(conn); free(conn->url); if (is_http(p)) conn->url = strdup(p); else { /* Relative URL */ int len = strlen(conn->host) + strlen(p) + 2; conn->url = malloc(len); if (conn->url) sprintf(conn->url, "%s/%s", conn->host, p); } if (!conn->url) { printf("Out of memory\n"); return 1; } /* This will cause a bogus Multiple * Closes error if it fails. */ if (build_request(conn)) return fail_redirect(conn); return 0; } } printf("%s: %d with no new location\n", conn->host, status); return status; }
int MPI_Send(void* buffer, int count, MPI_Datatype type, int dest, int tag, MPI_Comm comm) { if (!INITIALIZED) { return -1; } char input[128]; int size = count * mpi_sizeof(type); if (dest >= MPI_SIZE || dest == MPI_RANK) { printf("Illegal destination ID: %d\n", dest); exit(1); } struct connection_info* info = CONNECTION_INFO + dest; int sockfd = get_connection(POOL, info->host, info->port); if (sockfd < 0) { printf("Failed to open a socket to remote process\n"); exit(1); } sprintf(input, "MPI_Send\ncount=%d\nsource=%d\ndest=%d\ntag=%d\ncomm=%d\ntype=%d\n\n", size, MPI_RANK, dest, tag, comm, type); send(sockfd, input, strlen(input), 0); send(sockfd, buffer, size, 0); int bytes_read = 0; char output[8]; while (bytes_read < 8) { int ret = recv(sockfd, &output[bytes_read], 8 - bytes_read, 0); if (ret <= 0) { exit(1); } else { bytes_read += ret; char* char_output = (char*) output; if (char_output[bytes_read - 1] == 0) { break; } } } release_connection(POOL, info->host, info->port, sockfd); return 0; }
int build_request(struct connection *conn) { char *url, *host, *p; url = is_http(conn->url); if (!url) { #ifdef WANT_SSL printf("Only http/https supported\n"); #else printf("Only http supported\n"); #endif return 1; } p = strchr(url, '/'); if (p) { *p = '\0'; host = strdup(url); *p = '/'; url = p; } else { host = strdup(url); url = "/"; } if (!host) { printf("Out of memory\n"); return 1; } #ifdef REUSE_SOCKET if (CONN_OPEN) { if (hostcmp(conn->host, host)) { if (verbose) printf("New connection for %s\n", host); release_connection(conn); } else if (verbose) printf("Reuse connection for %s\n", conn->host); } #endif if (!get_buf(conn)) { free(host); return 1; } if (!CONN_OPEN) if (open_socket(conn, host)) { printf("Connection failed to %s\n", host); free(host); free_buf(conn); return 1; } if (proxy) snprintf(conn->buf, BUFSIZE, "%s http://%s/%s %s\r\n", method, host, url, http); else if (strchr(url, ' ')) { /* Some sites cannot handle spaces in the url. */ int n = sprintf(conn->buf, "%s ", method); char *in = url, *out = conn->buf + n; while (*in) if (*in == ' ') { *out++ = '%'; *out++ = '2'; *out++ = '0'; ++in; } else *out++ = *in++; sprintf(out, " %s\r\n", http); } else snprintf(conn->buf, BUFSIZE, "%s %s %s\r\n", method, url, http); add_full_header(conn, host); free(host); if (verbose > 1) printf("%s %s", proxy ? ">P" : ">", conn->buf); if (conn->referer) sprintf(conn->buf + strlen(conn->buf), "Referer: %.200s\r\n", conn->referer); strcat(conn->buf, "\r\n"); conn->curp = conn->buf; conn->length = strlen(conn->buf); return 0; }