/* create a single kb */
static void handle_cmd_create_kb(int client_fd, uint16_t datasize)
{
int rv, err;
unsigned char *msg = NULL;
int exit_val; /* exit value from 4s-backend-setup */
/* unpack client data into buffer */
unsigned char *buf = (unsigned char *)malloc(datasize);
rv = recv_from_client(client_fd, buf, datasize);
if (rv <= 0) {
/* errors already logged/handled */
free(buf);
return;
}
/* parse buffer into kb setup args struct */
fsa_kb_setup_args *ksargs = fsap_decode_cmd_create_kb(buf);
fsa_error(LOG_DEBUG, "ksargs->name: %s", ksargs->name);
fsa_error(LOG_DEBUG, "ksargs->node_id: %d", ksargs->node_id);
fsa_error(LOG_DEBUG, "ksargs->cluster_size: %d", ksargs->cluster_size);
fsa_error(LOG_DEBUG, "ksargs->num_segments: %d", ksargs->num_segments);
fsa_error(LOG_DEBUG, "ksargs->mirror_segments: %d",ksargs->mirror_segments);
fsa_error(LOG_DEBUG, "ksargs->model_files: %d", ksargs->model_files);
fsa_error(LOG_DEBUG, "ksargs->delete_existing: %d",ksargs->delete_existing);
/* should already have been checked by client */
if (!fsa_is_valid_kb_name((const char *)ksargs->name)) {
fsa_error(LOG_CRIT, "Invalid store name received from client");
send_error_message(client_fd, "store name invalid");
fsa_kb_setup_args_free(ksargs);
}
rv = fsab_create_local_kb(ksargs, &exit_val, &msg, &err);
/* encode message for client */
int len;
unsigned char *response =
fsap_encode_rsp_create_kb(err, ksargs->name, msg, &len);
fsa_error(LOG_DEBUG, "sending err: %d, kb_name: %s, msg: %s",
err, ksargs->name, msg);
fsa_kb_setup_args_free(ksargs);
free(msg);
fsa_error(LOG_DEBUG, "response size is %d bytes", len);
/* send entire response back to client */
rv = fsa_sendall(client_fd, response, &len);
free(response);
if (rv == -1) {
fsa_error(LOG_ERR, "failed to send response to client: %s",
strerror(errno));
return;
}
fsa_error(LOG_DEBUG, "%d bytes sent to client", len);
}
/* receive header from client, work out what request they want */
static void handle_client_data(int client_fd)
{
uint8_t cmdval; /* command client wants server to run */
uint16_t datasize; /* size of command packet */
int rv, nbytes;
unsigned char header_buf[ADM_HEADER_LEN];
/* block until we receive a full header */
nbytes = recv_from_client(client_fd, header_buf, ADM_HEADER_LEN);
if (nbytes <= 0) {
return;
}
/* decode header data we received from client */
rv = fsap_decode_header(header_buf, &cmdval, &datasize);
if (rv == -1) {
fsa_error(LOG_ERR, "unable to decode header sent by client");
close(client_fd);
FD_CLR(client_fd, &master_read_fds);
return;
}
fsa_error(LOG_DEBUG, "got command: %d, datasize: %d", cmdval, datasize);
/* work out which command the client is requesting */
switch (cmdval) {
case ADM_CMD_GET_KB_INFO_ALL:
handle_cmd_get_kb_info_all(client_fd);
break;
case ADM_CMD_GET_KB_INFO:
handle_cmd_get_kb_info(client_fd, datasize);
break;
case ADM_CMD_STOP_KB:
handle_cmd_stop_kb(client_fd, datasize);
break;
case ADM_CMD_START_KB:
handle_cmd_start_kb(client_fd, datasize);
break;
case ADM_CMD_STOP_KB_ALL:
handle_cmd_stop_kb_all(client_fd);
break;
case ADM_CMD_START_KB_ALL:
handle_cmd_start_kb_all(client_fd);
break;
case ADM_CMD_DELETE_KB:
handle_cmd_delete_kb(client_fd, datasize);
break;
case ADM_CMD_CREATE_KB:
handle_cmd_create_kb(client_fd, datasize);
break;
default:
fsa_error(LOG_ERR, "unknown client request");
close(client_fd);
FD_CLR(client_fd, &master_read_fds);
break;
}
}
int main(int argc, char* argv[]) {
init_database(database, table);
init_server(argc, argv);
recv_from_client();
close_server();
close_database();
return EXIT_SUCCESS;
}
static unsigned char *get_string_from_client(int client_fd, int len)
{
/* len = num chars in string to fetch */
unsigned char *str = (unsigned char *)malloc(len + 1);
/* get kb name from client */
int nbytes = recv_from_client(client_fd, str, len);
if (nbytes <= 0) {
/* errors already logged/handled */
free(str);
return NULL;
}
str[len] = '\0';
return str;
}
// attach a header then send len bytes from start of buf to
// the power strip, then wait for its response.
void send_to_client(uint8_t *buf, int32_t len)
{
if(len <= 0 || len > 255)
{
printf("send to client invalid message length\n");
return;
}
// assemble header
uint8_t header[2];
header[0] = MASTER_COMMAND_TRANSMISSION_START;
header[1] = len;
// retry if timeout happens
for (int32_t i = 0; i < TIMEOUT_MAX_RETRY; i++)
{
if(i > 0)
printf("send command timeout, retry #%d\n", i);
// send out header
if(send(sockfd, header, 2, 0) == -1)
{
perror("send");
exit(0);
}
// send out data
if(send(sockfd, buf, len, 0) == -1)
{
perror("send");
exit(0);
}
// wait for response
if(recv_from_client(recv_buf) == 0)
return;
}
// if all retries result in timeout, exit the program
printf("can not reach client\n");
exit(0);
}
