int main(int argc ,char *argv[])
{
int sock_fd,newfd;
sock_fd=system_init();//服务器初始化
connect_to_client(sock_fd);//和客户端进行连接
return 0;
}
void connect_function(GtkWidget *widget,gpointer data)
{
if(!connect_bool && connection_status() == 0) {
if (connect_to_client() == 0) {
gtk_button_set_label(GTK_BUTTON(widget), "Connect");
gtk_label_set_text(GTK_LABEL(helpLabel), "client offline");
g_timeout_add_seconds(4, reset_help_label, (gpointer) helpLabel);
return;
} else {
sendMessage("100:start");
gtk_button_set_label(GTK_BUTTON(widget), "Disconnect");
connect_bool = 1;
}
} else {
connect_bool = 0;
sendMessage("100:stop");
gtk_button_set_label(GTK_BUTTON(buttonDevice1), "Device1");
gtk_button_set_label(GTK_BUTTON(buttonDevice2), "Device2");
gtk_button_set_label(GTK_BUTTON(buttonDevice3), "Device3");
gtk_button_set_label(GTK_BUTTON(buttonDevice4), "Device4");
stop_audio_from_mic();
disconnect();
gtk_button_set_label(GTK_BUTTON(widget), "Connect");
}
}
int integrity_terminal_worker()
{
int length;
int sockfd;
struct client_transaction_t client_data;
extern int errno;
/* Connect to the client program. */
sockfd = connect_to_client(hostname, client_port);
if (sockfd < 1) {
LOG_ERROR_MESSAGE("connect_to_client() failed, thread exiting...");
printf("connect_to_client() failed, thread exiting...");
pthread_exit(NULL);
}
client_data.transaction = INTEGRITY;
generate_input_data(client_data.transaction,
&client_data.transaction_data, table_cardinality.warehouses);
#ifdef DEBUG
printf("executing transaction %c\n",
transaction_short_name[client_data.transaction]);
fflush(stdout);
LOG_ERROR_MESSAGE("executing transaction %c",
transaction_short_name[client_data.transaction]);
#endif /* DEBUG */
length = send_transaction_data(sockfd, &client_data);
length = receive_transaction_data(sockfd, &client_data);
close(sockfd);
return client_data.status;
}
void cmd_list(struct_client *clt)
{
int oldfd;
if (clt->data.transfert_mode == UNSET)
{
printf("520 LIST you have to use PORT or PASV before\n");
return ;
}
if (clt->data.transfert_mode == PASV)
list_passiv(clt);
else if (clt->data.transfert_mode == PORT)
{
printf("150 Opening BINARY mode data connection for 'ls'\n");
if (connect_to_client(clt) == -1)
{
printf("520 LIST impossible to reach client\n");
return ;
}
oldfd = xdup(1);
xdup2(clt->data.sock, 1);
system("ls -la");
xdup2(oldfd, 1);
printf("226 Transfer complete\n");
close_data_chan(clt, -1);
}
}
int main(int argc, char* argv[]) {
// The socket through which we communicate with the client
int connection;
Arguments args;
parse_arguments(&args, argc, argv);
connection = connect_to_client();
communicate(connection, &args);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
SOCKET client_socket, server_socket;
int read_size;
server_socket = create_server();
client_socket = connect_to_client(server_socket);
read_size = main_echo_cycle(client_socket);
check_recv_last_response(read_size);
cleanup(server_socket, client_socket);
return 0;
}
/****************************************************************************
*
* NAME:
*
* DESCRIPTION:
*
* PARAMETERS: Name RW Usage
* None.
*
* RETURNS:
* None.
*
* NOTES:
* None.
****************************************************************************/
void on_receive()
{
char message[100]={0};
printf("Connected\n\r");
sprintf(message,"%d-%d-%d-%d-%d",we.publicIP[0],we.publicIP[1],we.publicIP[2],we.publicIP[3],we.publicPORT);
printf("========================================================\n\r");
printf("\tYour connection ID is %s\n\r",message);
printf("========================================================\n\r");
do {
memset(message,0,sizeof(message));
printf("Provide connection ID of other peer: ");
scanf("%s",(char *) &message);
printf("\n\r");
}while(conneciton_id_validate(message, strlen(message))!=1);
connect_to_client();
}
void *terminal_worker(void *data)
{
#ifndef STANDALONE
int length;
int sockfd;
#endif /* NOT STANDALONE */
struct terminal_context_t *tc;
struct client_transaction_t client_data;
double threshold;
int keying_time;
struct timespec thinking_time, rem;
int mean_think_time; /* In milliseconds. */
struct timeval rt0, rt1;
double response_time;
extern int errno;
int rc;
int local_seed;
#ifdef STANDALONE
struct db_context_t dbc;
struct transaction_queue_node_t *node =
(struct transaction_queue_node_t *)
malloc(sizeof(struct transaction_queue_node_t));
extern char sname[32];
extern int exiting;
#ifdef LIBPQ
extern char postmaster_port[32];
#endif /* LIBPQ */
#ifdef LIBMYSQL
extern char dbt2_mysql_port[32];
#endif /* LIBMYSQL */
#endif /* STANDALONE */
tc = (struct terminal_context_t *) data;
/* Each thread needs to seed in Linux. */
if (seed == -1) {
struct timeval tv;
unsigned long junk; /* Purposely used uninitialized */
gettimeofday(&tv, NULL);
local_seed = getpid() ^ (int) pthread_self() ^ tv.tv_sec ^
tv.tv_usec ^ junk;
} else {
local_seed = seed;
}
printf("seed: %u\n", local_seed);
fflush(stdout);
srand(local_seed);
#ifdef STANDALONE
#ifdef ODBC
db_init(sname, DB_USER, DB_PASS);
#endif /* ODBC */
#ifdef LIBPQ
db_init(DB_NAME, sname, postmaster_port);
#endif /* LIBPQ */
#ifdef LIBMYSQL
printf("CONNECTED TO DB |%s| |%s| |%s|\n", DB_NAME, sname, dbt2_mysql_port);
db_init(sname, "", dbt2_mysql_port);
#endif /* LIBMYSQL */
if (!exiting && connect_to_db(&dbc) != OK) {
LOG_ERROR_MESSAGE("db_connect() error, terminating program");
printf("cannot connect to database, exiting...\n");
exit(1);
}
#else
/* Connect to the client program. */
sockfd = connect_to_client(hostname, client_port);
if (sockfd < 1) {
LOG_ERROR_MESSAGE( "connect_to_client() failed, thread exiting...");
printf("connect_to_client() failed, thread exiting...");
pthread_exit(NULL);
}
#endif /* STANDALONE */
do {
if (mode_altered == 1) {
/*
* Determine w_id and d_id for the client per
* transaction.
*/
tc->w_id = w_id_min + get_random(w_id_max - w_id_min + 1);
tc->d_id = get_random(table_cardinality.districts) + 1;
}
/*
* Determine which transaction to execute, minimum keying time,
* and mean think time.
*/
threshold = get_percentage();
if (threshold < transaction_mix.new_order_threshold) {
client_data.transaction = NEW_ORDER;
keying_time = key_time.new_order;
mean_think_time = think_time.new_order;
} else if (transaction_mix.payment_actual != 0 &&
threshold < transaction_mix.payment_threshold) {
client_data.transaction = PAYMENT;
keying_time = key_time.payment;
mean_think_time = think_time.payment;
} else if (transaction_mix.order_status_actual != 0 &&
threshold < transaction_mix.order_status_threshold) {
client_data.transaction = ORDER_STATUS;
keying_time = key_time.order_status;
mean_think_time = think_time.order_status;
} else if (transaction_mix.delivery_actual != 0 &&
threshold < transaction_mix.delivery_threshold) {
client_data.transaction = DELIVERY;
keying_time = key_time.delivery;
mean_think_time = think_time.delivery;
} else {
client_data.transaction = STOCK_LEVEL;
keying_time = key_time.stock_level;
mean_think_time = think_time.stock_level;
}
#ifdef DEBUG
printf("executing transaction %c\n",
transaction_short_name[client_data.transaction]);
fflush(stdout);
LOG_ERROR_MESSAGE("executing transaction %c",
transaction_short_name[client_data.transaction]);
#endif /* DEBUG */
/* Generate the input data for the transaction. */
if (client_data.transaction != STOCK_LEVEL) {
generate_input_data(client_data.transaction,
&client_data.transaction_data, tc->w_id);
} else {
generate_input_data2(client_data.transaction,
&client_data.transaction_data, tc->w_id, tc->d_id);
}
/* Keying time... */
pthread_mutex_lock(
&mutex_terminal_state[KEYING][client_data.transaction]);
++terminal_state[KEYING][client_data.transaction];
pthread_mutex_unlock(
&mutex_terminal_state[KEYING][client_data.transaction]);
if (time(NULL) < stop_time) {
sleep(keying_time);
} else {
break;
}
pthread_mutex_lock(
&mutex_terminal_state[KEYING][client_data.transaction]);
--terminal_state[KEYING][client_data.transaction];
pthread_mutex_unlock(
&mutex_terminal_state[KEYING][client_data.transaction]);
/* Note this thread is executing a transation. */
pthread_mutex_lock(
&mutex_terminal_state[EXECUTING][client_data.transaction]);
++terminal_state[EXECUTING][client_data.transaction];
pthread_mutex_unlock(
&mutex_terminal_state[EXECUTING][client_data.transaction]);
/* Execute transaction and record the response time. */
if (gettimeofday(&rt0, NULL) == -1) {
perror("gettimeofday");
}
#ifdef STANDALONE
memcpy(&node->client_data, &client_data, sizeof(client_data));
/*
enqueue_transaction(node);
node = get_node();
if (node == NULL) {
LOG_ERROR_MESSAGE("Cannot get a transaction node.\n");
}
*/
rc = process_transaction(node->client_data.transaction, &dbc,
&node->client_data.transaction_data);
if (rc == ERROR) {
LOG_ERROR_MESSAGE("process_transaction() error on %s",
transaction_name[node->client_data.transaction]);
}
#else /* STANDALONE */
length = send_transaction_data(sockfd, &client_data);
length = receive_transaction_data(sockfd, &client_data);
rc = client_data.status;
#endif /* STANDALONE */
if (gettimeofday(&rt1, NULL) == -1) {
perror("gettimeofday");
}
response_time = difftimeval(rt1, rt0);
pthread_mutex_lock(&mutex_mix_log);
if (rc == OK) {
fprintf(log_mix, "%d,%c,%f,%d\n", (int) time(NULL),
transaction_short_name[client_data.transaction],
response_time, (int) pthread_self());
} else if (rc == STATUS_ROLLBACK) {
fprintf(log_mix, "%d,%c,%f,%d\n", (int) time(NULL),
toupper(transaction_short_name[client_data.transaction]),
response_time, (int) pthread_self());
} else if (rc == ERROR) {
fprintf(log_mix, "%d,%c,%f,%d\n", (int) time(NULL),
'E', response_time, (int) pthread_self());
}
fflush(log_mix);
pthread_mutex_unlock(&mutex_mix_log);
pthread_mutex_lock(&mutex_terminal_state[EXECUTING][client_data.transaction]);
--terminal_state[EXECUTING][client_data.transaction];
pthread_mutex_unlock(&mutex_terminal_state[EXECUTING][client_data.transaction]);
/* Thinking time... */
pthread_mutex_lock(&mutex_terminal_state[THINKING][client_data.transaction]);
++terminal_state[THINKING][client_data.transaction];
pthread_mutex_unlock(&mutex_terminal_state[THINKING][client_data.transaction]);
if (time(NULL) < stop_time) {
thinking_time.tv_nsec = (long) get_think_time(mean_think_time);
thinking_time.tv_sec = (time_t) (thinking_time.tv_nsec / 1000);
thinking_time.tv_nsec = (thinking_time.tv_nsec % 1000) * 1000000;
while (nanosleep(&thinking_time, &rem) == -1) {
if (errno == EINTR) {
memcpy(&thinking_time, &rem, sizeof(struct timespec));
} else {
LOG_ERROR_MESSAGE(
"sleep time invalid %d s %ls ns",
thinking_time.tv_sec,
thinking_time.tv_nsec);
break;
}
}
}
pthread_mutex_lock(&mutex_terminal_state[THINKING][client_data.transaction]);
--terminal_state[THINKING][client_data.transaction];
pthread_mutex_unlock(&mutex_terminal_state[THINKING][client_data.transaction]);
} while (time(NULL) < stop_time);
#ifdef STANDALONE
/*recycle_node(node);*/
#endif /* STANDALONE */
/* Note when each thread has exited. */
pthread_mutex_lock(&mutex_mix_log);
fprintf(log_mix, "%d,TERMINATED,%d\n", (int) time(NULL),
(int) pthread_self());
fflush(log_mix);
pthread_mutex_unlock(&mutex_mix_log);
return NULL; /* keep the compiler quiet */
}