void execute_and_or_command(command_t command) { if(command->type == AND_COMMAND){ execute_wrapper(command->u.command[0]); command->status = command->u.command[0]->status; if(command_status(command->u.command[0]) == 0){ execute_wrapper(command->u.command[1]); command->status = command->u.command[1]->status; } else command->status = 1; } if(command->type == OR_COMMAND){ execute_wrapper(command->u.command[0]); command->status = command->u.command[0]->status; //printf("%d\n",command->status); if(command_status(command->u.command[0]) > 0){ execute_wrapper(command->u.command[1]); command->status = command->u.command[1]->status; } else command->status = 0; } }
static void hci_link_control(uint16_t ocf, int plen, uint8_t *data) { uint8_t status; const uint16_t ogf = OGF_LINK_CTL; switch (ocf) { case OCF_CREATE_CONN: command_status(ogf, ocf, 0x00); create_connection(data); break; case OCF_ACCEPT_CONN_REQ: command_status(ogf, ocf, 0x00); accept_connection(data); break; case OCF_DISCONNECT: command_status(ogf, ocf, 0x00); disconnect(data); break; default: status = 0x01; command_complete(ogf, ocf, 1, &status); break; } }
void executeANDCommand(command_t c) { callCommand(c->u.command[0]); int cStatus1 = command_status(c->u.command[0]); if (cStatus1) // if true (fails, returns -1), whole AND command fails, you lose, get a life c->status = cStatus1; else { // false, first command succeeded, run second command and save status in AND command callCommand(c->u.command[1]); c->status = command_status(c->u.command[1]); } }
void executingOr(command_t c) { execute_switch(c->u.command[0]); if (command_status(c->u.command[0]) == 0) { c->status = command_status(c->u.command[0]); } else { execute_switch(c->u.command[1]); c->status = command_status(c->u.command[1]); } }
void executeORCommand(command_t c) { callCommand(c->u.command[0]); int cStatus1 = command_status(c->u.command[0]); if (cStatus1) // if true (fails, returns -1), try the other command { callCommand(c->u.command[1]); c->status = command_status(c->u.command[1]); } else { // false, first command succeeded, can forget about the second command c->status = cStatus1; } }
bool xRedisClient::lset(const RedisDBIdx& dbi, const string& key, int index, const string& value) { if (0 == key.length()) { return false; } SETDEFAULTIOTYPE(MASTER); return command_status(dbi, "LSET %s %d %s", key.c_str(), index, value.c_str()); }
static void hci_status_param(uint16_t ocf, int plen, uint8_t *data) { read_local_amp_info_rp ai; const uint16_t ogf = OGF_STATUS_PARAM; switch (ocf) { case OCF_READ_LOCAL_AMP_INFO: memset(&ai, 0, sizeof(ai)); /* BT only */ ai.amp_status = 0x01; ai.max_pdu_size = htobl(L2CAP_DEFAULT_MTU); ai.controller_type = HCI_AMP; ai.max_amp_assoc_length = htobl(HCI_MAX_ACL_SIZE); /* No flushing at all */ ai.max_flush_timeout = 0xFFFFFFFF; ai.best_effort_flush_timeout = 0xFFFFFFFF; command_complete(ogf, ocf, sizeof(ai), &ai); break; default: command_status(ogf, ocf, 0x01); break; } }
bool xRedisClient::ltrim(const RedisDBIdx& dbi, const string& key, int start, int end) { if (0 == key.length()) { return false; } SETDEFAULTIOTYPE(MASTER); return command_status(dbi, "LTRIM %s %d %d", key.c_str(), start, end); }
bool CRedisClient::ltrim(const CString &key, int start, int stop) { CString sStart, sStop; sStart.Format("%d", start); sStop.Format("%d", stop); return command_status("LTRIM %s %s %s", (LPCSTR)key, (LPCSTR)sStart, (LPCSTR)sStop); }
bool CRedisClient::zremrangebyrank(const CString &key, int start, int stop) { CString sStart, sStop; sStart.Format("%d", start); sStop.Format("%d", stop); return command_status("ZREMRANGEBYRANK %s %s %s", (LPCSTR)key, (LPCSTR)sStart, (LPCSTR)sStop); }
void execute_and_command(command_t c) { command_t left = c->u.command[0]; command_t right = c->u.command[1]; execute_command(left, 0);//recursively call the execute command if(command_status(left) == 0) { execute_command(right,0); c->status = command_status(right); } else//the left command is not runned successfully { //there is no need to execute the right command c->status = command_status(left); } }
int main (int argc, char **argv) { int opt; int command_number = 1; int print_tree = 0; int time_travel = 0; program_name = argv[0]; for (;;) switch (getopt (argc, argv, "pt")) { case 'p': print_tree = 1; break; case 't': time_travel = 1; break; default: usage (); break; case -1: goto options_exhausted; } options_exhausted:; // There must be exactly one file argument. if (optind != argc - 1) usage (); script_name = argv[optind]; FILE *script_stream = fopen (script_name, "r"); if (! script_stream) { return 0; //error (1, errno, "%s: cannot open", script_name); } command_stream_t command_stream = make_command_stream (get_next_byte, script_stream); command_t last_command = NULL; command_t command; void execute_timeTravel(command_stream_t c); if(time_travel ==1) { //execute in time travel mode execute_timeTravel(command_stream); } else{ //this means we are not in timetravel mode while ((command = read_command_stream (&command_stream))) { if (print_tree) { printf ("# %d\n", command_number++); print_command (command); } else { last_command = command; execute_command (command); } } } //close the else statement return print_tree || !last_command ? 0 : command_status (last_command); }
int main (int argc, char **argv) { int opt; int command_number = 1; int print_tree = 0; int time_travel = 0; program_name = argv[0]; for (;;) switch (getopt (argc, argv, "pt")) { case 'p': print_tree = 1; break; case 't': time_travel = 1; break; default: usage (); break; case -1: goto options_exhausted; } options_exhausted:; // There must be exactly one file argument. if (optind != argc - 1) usage (); script_name = argv[optind]; FILE *script_stream = fopen (script_name, "r"); if (! script_stream) error (1, errno, "%s: cannot open", script_name); command_stream_t command_stream = make_command_stream (get_next_byte, script_stream); command_t last_command = NULL; command_t command; if (!time_travel){ while ((command = read_command_stream (command_stream))) { if (print_tree) { printf ("# %d\n", command_number++); print_command (command); } else { last_command = command; execute_command (command, time_travel); } } } else{ parallel_execute (command_stream); } return print_tree || !last_command ? 0 : command_status (last_command); }
static void hci_link_policy(uint16_t ocf, int plen, uint8_t *data) { const uint16_t ogf = OGF_INFO_PARAM; switch (ocf) { default: command_status(ogf, ocf, 0x01); break; } }
int main (int argc, char **argv) { int command_number = 1; bool print_tree = false; char const *profile_name = 0; program_name = argv[0]; for (;;) switch (getopt (argc, argv, "p:t")) { case 'p': profile_name = optarg; break; case 't': print_tree = true; break; default: usage (); break; case -1: goto options_exhausted; } options_exhausted:; // There must be exactly one file argument. if (optind != argc - 1) usage (); script_name = argv[optind]; FILE *script_stream = fopen (script_name, "r"); if (! script_stream) error (1, errno, "%s: cannot open", script_name); command_stream_t command_stream = make_command_stream (get_next_byte, script_stream); int profiling = -1; if (profile_name) { profiling = prepare_profiling (profile_name); if (profiling < 0) error (1, errno, "%s: cannot open", profile_name); } command_t last_command = NULL; command_t command; while ((command = read_command_stream (command_stream))) { if (print_tree) { printf ("# %dn", command_number++); print_command (command); } else { last_command = command; execute_command (command, profiling); } } return print_tree || !last_command ? 0 : command_status (last_command); }
bool xRedisClient::mset(const DBIArray& vdbi, const VDATA& vData) { DBIArray::const_iterator iter_dbi = vdbi.begin(); VDATA::const_iterator iter_data = vData.begin(); for (; iter_data != vData.end(); iter_dbi++) { const string &key = (*iter_data++); const string &value = (*iter_data++); const RedisDBIdx& dbi = *iter_dbi; SETDEFAULTIOTYPE(SLAVE); command_status(dbi, "SET %s %s", key.c_str(), value.c_str()); } return true; }
void execute_graph(int** graph, command_stream_t stream, int N) { int i,j,n = 0, m, np = N; while (graph[n]) n++; command_t* command_stream = malloc(sizeof(command_t)*n); int count = 0, status; while(count < n) command_stream[count++] = read_command_stream(stream); int *executed = malloc(sizeof(int)*n); for (i = 0; i<n; i++) executed[i] = 0; m = n; while (m > 0) { for (i = 0; i < n; i++) if (!executed[i]) { int dependency = 0; for (j = 0; j < n; j++) if (graph[i][j]) dependency = 1; if (!dependency) { if (np == 0) // if the limit of subprocesses is met { waitpid(WAIT_ANY, &status, WUNTRACED); // wait for any child to return if (errno == EINTR || errno == EINVAL) perror("waitpid"); np = 1; } // the check is put right before forking, so that the efficiency is maximized. m--; np--; executed[i] = 1; pid_t pid = fork(); if (!pid) {/* child process execute the command */ execute_command(command_stream[i], 0); for (j = 0; j < n; j++) graph[j][i] = 0; exit(command_status(command_stream[i])); } } } } while (waitpid(WAIT_ANY, &status, WUNTRACED)) { if (errno == ECHILD) break; if (errno == EINTR || errno == EINVAL) perror("waitpid"); } }
void execute_or_command (command_t c) { execute_command(c->u.command[0], 0); //puts("TESTOR"); if (command_status(c->u.command[0]) == 0) { c->status = c->u.command[0]->status; } else { execute_command(c->u.command[1], 0); c->status = c->u.command[1]->status; //printf("%d\n", c->type); } }
void execute_and_command (command_t c) { execute_command(c->u.command[0], 0); if (command_status(c->u.command[0]) == 0) { // run the second command execute_command(c->u.command[1], 0); // set the status of the AND command c->status = c->u.command[1]->status; } else { // do not run c2 // set the status of the AND command c->status = c->u.command[0]->status; } }
bool CRedisClient::hmset(const CString &key,ATF_MAP map) { bool bRet = true; //iRetVal = 0; ATF_MAP::iterator it=map.begin(); for( ;it!=map.end();it++) { CString strField = it->first; CString strValue = it->second; if(strField.GetLength() > 0 && strValue.GetLength() > 0) { bRet = bRet && command_status("HSET %s %s %s", (LPCSTR)key, (LPCSTR)strField, (LPCSTR)strValue); //iRetVal++; } } return bRet; }
static void hci_command(uint8_t *data) { hci_command_hdr *ch; uint8_t *ptr = data; uint16_t ogf, ocf; ch = (hci_command_hdr *) ptr; ptr += HCI_COMMAND_HDR_SIZE; ch->opcode = btohs(ch->opcode); ogf = cmd_opcode_ogf(ch->opcode); ocf = cmd_opcode_ocf(ch->opcode); switch (ogf) { case OGF_LINK_CTL: hci_link_control(ocf, ch->plen, ptr); break; case OGF_LINK_POLICY: hci_link_policy(ocf, ch->plen, ptr); break; case OGF_HOST_CTL: hci_host_control(ocf, ch->plen, ptr); break; case OGF_INFO_PARAM: hci_info_param(ocf, ch->plen, ptr); break; case OGF_STATUS_PARAM: hci_status_param(ocf, ch->plen, ptr); break; case OGF_LE_CTL: hci_le_control(ocf, ch->plen, ptr); break; default: command_status(ogf, ocf, 0x01); break; } }
static void hci_le_control(uint16_t ocf, int plen, uint8_t *data) { le_read_buffer_size_rp bs; const uint16_t ogf = OGF_LE_CTL; switch (ocf) { case OCF_LE_READ_BUFFER_SIZE: bs.status = 0; bs.pkt_len = htobs(VHCI_ACL_MTU); bs.max_pkt = htobs(VHCI_ACL_MAX_PKT); command_complete(ogf, ocf, sizeof(bs), &bs); break; default: command_status(ogf, ocf, 0x01); break; } }
void executingSubshell(command_t c) { int eStatus; pid_t pid = fork(); if (pid < 0) { error(1, 0, "fork was unsuccessful\n"); } else if (pid == 0) // child process { setupInOut(c); // redirects inputs and outputs execute_switch(c->u.subshell_command); _exit(command_status(c->u.subshell_command)); } else //parent process { waitpid(pid, &eStatus, 0); c->status = WEXITSTATUS(eStatus); } }
int execute_command_type(command_t c) { switch(c->type){ case SIMPLE_COMMAND: execute(c); break; case PIPE_COMMAND: execute_pipe(c); break; case AND_COMMAND: // the first command already fails if(execute_command_type(c->u.command[0]) != 0){ c->status = command_status(c->u.command[0]); }else{ c->status = execute_command_type(c->u.command[1]); } break; case OR_COMMAND: if(execute_command_type(c->u.command[0]) == 0){ c->status = 0; }else{ // try the second command if the first fails c->status = execute_command_type(c->u.command[1]); } break; case SUBSHELL_COMMAND: c->status = execute_command_type(c->u.subshell_command); break; case SEQUENCE_COMMAND: // return the status of the last command execute_sequence(c); break; } return c->status; }
int excute_parallel (command_array *cmd_arr, size_t arr_size) { int status; size_t i; node_t n; node_t pid_list; // List of pids to wait for pid_list = initialize_llist (); i = 0; // Go through all the processes while (i < arr_size) { int pid; size_t current = cmd_arr[i].ranking; while (i < arr_size && cmd_arr[i].ranking == current) { pid = fork(); // Spawn the child process to execute the command if (pid == 0) // child process { execute_command (cmd_arr[i].command_tree); exit (command_status (cmd_arr[i].command_tree)); } insert_node (pid_list, pid); i++; } // Wait for all the processes of this ranking to finish for (n = pid_list->next; n != pid_list; n = n->next) waitpid(n->val, &status, 0); // Processes finished waiting for while (pid_list != pid_list->next) remove_last_element (pid_list); } // Return the status of the last process waited on return status; }
/** * The callback function for handling the !history command. */ static int command_history(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd) { struct cbuffer* buf; struct chat_history_data* data = (struct chat_history_data*) plugin->ptr; struct plugin_command_arg_data* arg = plugin->hub.command_arg_next(plugin, cmd, plugin_cmd_arg_type_integer); int maxlines; if (!list_size(data->chat_history)) return command_status(plugin, user, cmd, cbuf_create_const("No messages.")); if (arg) maxlines = arg->data.integer; else maxlines = data->history_default; buf = cbuf_create(MAX_HISTORY_SIZE); cbuf_append_format(buf, "*** %s: Chat History:\n", cmd->prefix); get_messages(data, maxlines, buf); plugin->hub.send_message(plugin, user, cbuf_get(buf)); cbuf_destroy(buf); return 0; }
int main (int argc, char **argv) { int command_number = 1; bool print_tree = false; char const *profile_name = 0; program_name = argv[0]; for (;;) switch (getopt (argc, argv, "p:t")) { case 'p': profile_name = optarg; break; case 't': print_tree = true; break; default: usage (); break; case -1: goto options_exhausted; } options_exhausted:; // There must be exactly one file argument. if (optind != argc - 1) usage (); script_name = argv[optind]; FILE *script_stream = fopen (script_name, "r"); if (! script_stream) error (1, errno, "%s: cannot open", script_name); command_stream_t command_stream = make_command_stream (get_next_byte, script_stream); int profiling = -1; if (profile_name) { profiling = prepare_profiling (profile_name); if (profiling < 0) error (1, errno, "%s: cannot open", profile_name); } command_t last_command = NULL; command_t command; //timer starts struct timespec absolute; double start_time, prev_user_CPU, prev_sys_CPU; get_timer(&start_time, &prev_user_CPU, &prev_sys_CPU); while ((command = read_command_stream (command_stream))) { if (print_tree) { printf ("# %d\n", command_number++); print_command (command); } else { last_command = command; execute_command (command, profiling); } } //timer stops clock_gettime(CLOCK_REALTIME, &absolute); double absolute_time = absolute.tv_sec + (double)absolute.tv_nsec/1000000000.0; double end_time, current_user_CPU, current_sys_CPU; get_timer(&end_time, ¤t_user_CPU, ¤t_sys_CPU); double real_time = end_time - start_time; double userCPU = current_user_CPU-prev_user_CPU; double sysCPU = current_sys_CPU-prev_sys_CPU; pid_t pid = getpid(); char buffer[1024]; sprintf(buffer, "%f %f %.3f %.3f %d\n", absolute_time, real_time, userCPU, sysCPU, (int)pid); write(profiling, buffer, strlen(buffer)); return print_tree || !last_command ? 0 : command_status (last_command); }
int main (int argc, char **argv) { int command_number = 1; bool print_tree = false; bool time_travel = false; bool output_to_file=false; bool error_to_file=false; bool all_to_file=false; program_name = argv[0]; for (;;) switch (getopt (argc, argv, "ptvxoehas")) { case 'p': print_tree = true; break; case 't': time_travel = true; break; case 'x': x_option=true;break; case 'v': v_option=true;break; case 'o': output_to_file=true;break; case 'e': error_to_file=true;break; case 'a': all_to_file=true;break; case 's': s_option=true;break; case 'h': fprintf(stderr,"option p to print command trees without execution.\noption t to exploit parallelism between command trees.\n"); fprintf(stderr,"option x to print simple commands and their arguments before execution.\noption v to print shell input before execution.\n"); fprintf(stderr,"option o to save output to output.txt.\noption e to save error to error.txt.\n"); fprintf(stderr,"option a to save output and error to output_and_error.txt.\n"); fprintf(stderr,"option s to slowly go through script, one command tree at a time\n"); fprintf(stderr,"option x and v not available in combination with option t.\n"); fprintf(stderr,"options x or v in combination with option s to tell what the next command is before continuing.\n"); return 0; default: usage (); break; case -1: goto options_exhausted; } options_exhausted:; // There must be exactly one file argument. if (optind != argc - 1) usage (); if(time_travel) { if(x_option || v_option || s_option) { no_debug_time_travel(); } } if(print_tree && s_option) { error (1, 0, "usage: %s [-pxvtoehas] SCRIPT-FILE, cannot use step_mode and print tree", program_name); } script_name = argv[optind]; if(s_option) { fprintf(stderr,"Step mode enabled. Press d to disable step mode, press a to abort further execution, or press enter to move onto the next command.\n"); } if (all_to_file==false) { if(output_to_file==true) { int fd=open("output.txt",O_CREAT|O_TRUNC|O_WRONLY,0644); if(fd<0) { fprintf(stderr,"No available file descriptors"); return(1); } dup2(fd,1); close(fd); } if(error_to_file==true) { int fd=open("error.txt",O_CREAT|O_TRUNC|O_WRONLY,0644); if(fd<0) { fprintf(stderr,"No available file descriptors"); return(1); } dup2(fd,2); close(fd); } } else//all to file is true { int fd=open("output_and_error.txt",O_CREAT|O_TRUNC|O_WRONLY,0644); if(fd<0) { fprintf(stderr,"No available file descriptors"); return(1); } dup2(fd,2); dup2(fd,1); close(fd); } FILE *script_stream = fopen (script_name, "r"); if (! script_stream) error (1, errno, "%s: cannot open", script_name); command_stream_t command_stream = make_command_stream (get_next_byte, script_stream); command_t last_command = NULL; command_t command; if(time_travel) { struct dependency_graph* graph=create_graph(command_stream); int final_status=0; final_status=execute_graph(graph); } if(print_tree==true || time_travel==false) { while ((command = read_command_stream (command_stream))) { if (print_tree) { printf ("# %d\n", command_number++); print_command (command); } else { last_command = command; execute_command (command, time_travel); } } } return print_tree || !last_command ? 0 : command_status (last_command); }
int main (int argc, char **argv) { int command_number = 1; bool print_tree = false; bool time_travel = false; bool time_travel_limit = false; int num_of_processes =0; program_name = argv[0]; char c = ' '; for (;;) switch (getopt (argc, argv, "ptj")) { case 'p': print_tree = true;c = 'p'; break; case 't': time_travel = true; c = 't';break; case 'j': time_travel_limit = true; num_of_processes = atoi(argv[2]); c = 'j'; break; default: usage (); break; case -1: goto options_exhausted; } options_exhausted:; // There must be exactly one file argument. if (optind != argc - 1) { if (argc > 1 && c == 'j' && optind == argc-2) {} else { usage (); } } script_name = argv[argc - 1]; FILE *script_stream = fopen (script_name, "r"); if (! script_stream) error (1, errno, "%s: cannot open", script_name); command_stream_t command_stream = make_command_stream (get_next_byte, script_stream); command_t last_command = NULL; command_t command; while ((command = read_command_stream (command_stream))) { if (print_tree) { printf ("# %d\n", command_number++); print_command (command); } else { if (time_travel == false && time_travel_limit == false) { last_command = command; execute_command (command, time_travel); } } } if (time_travel == true) {execute(command_stream);} if (time_travel_limit == true) {execute_limit(command_stream, num_of_processes);} return print_tree || !last_command ? 0 : command_status (last_command); }
int main(int argc, char *argv[]) { char buf[1024]; int i; #ifdef TIOCGWINSZ struct winsize ws; if (ioctl(fileno(stdout), TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0) TERMWIDTH = ws.ws_col; #endif /* Start handling the arguments. * monetdb [monetdb_options] command [options] [database [...]] * this means we first scout for monetdb_options which stops as soon * as we find a non-option argument, which then must be command */ /* first handle the simple no argument case */ if (argc <= 1) { command_help(0, NULL); return(1); } /* handle monetdb_options */ for (i = 1; argc > i && argv[i][0] == '-'; i++) { switch (argv[i][1]) { case 'v': command_version(); return(0); case 'q': monetdb_quiet = 1; break; case 'h': if (strlen(&argv[i][2]) > 0) { mero_host = &argv[i][2]; } else { if (i + 1 < argc) { mero_host = argv[++i]; } else { fprintf(stderr, "monetdb: -h needs an argument\n"); return(1); } } break; case 'p': if (strlen(&argv[i][2]) > 0) { mero_port = atoi(&argv[i][2]); } else { if (i + 1 < argc) { mero_port = atoi(argv[++i]); } else { fprintf(stderr, "monetdb: -p needs an argument\n"); return(1); } } break; case 'P': /* take care we remove the password from argv so it * doesn't show up in e.g. ps -ef output */ if (strlen(&argv[i][2]) > 0) { mero_pass = strdup(&argv[i][2]); memset(&argv[i][2], 0, strlen(mero_pass)); } else { if (i + 1 < argc) { mero_pass = strdup(argv[++i]); memset(argv[i], 0, strlen(mero_pass)); } else { fprintf(stderr, "monetdb: -P needs an argument\n"); return(1); } } break; case '-': /* skip -- */ if (argv[i][2] == '\0') break; if (strcmp(&argv[i][2], "version") == 0) { command_version(); return(0); } else if (strcmp(&argv[i][2], "help") == 0) { command_help(0, NULL); return(0); } default: fprintf(stderr, "monetdb: unknown option: %s\n", argv[i]); command_help(0, NULL); return(1); break; } } /* check consistency of -h -p and -P args */ if (mero_pass != NULL && (mero_host == NULL || *mero_host == '/')) { fprintf(stderr, "monetdb: -P requires -h to be used with a TCP hostname\n"); exit(1); } else if (mero_host != NULL && *mero_host != '/' && mero_pass == NULL) { fprintf(stderr, "monetdb: -h requires -P to be used\n"); exit(1); } /* see if we still have arguments at this stage */ if (i >= argc) { command_help(0, NULL); return(1); } /* commands that do not need merovingian to be running */ if (strcmp(argv[i], "help") == 0) { command_help(argc - i, &argv[i]); return(0); } else if (strcmp(argv[i], "version") == 0) { command_version(); return(0); } /* use UNIX socket if no hostname given */ if (mero_host == NULL || *mero_host == '/') { /* a socket looks like /tmp/.s.merovingian.<tcpport>, try * finding such port. If mero_host is set, it is the location * where we should search, which defaults to '/tmp' */ if (mero_host == NULL) mero_host = "/tmp"; /* first try the port given (or else its default) */ snprintf(buf, sizeof(buf), "%s/.s.merovingian.%d", mero_host, mero_port == -1 ? 50000 : mero_port); if (control_ping(buf, -1, NULL) == 0) { mero_host = buf; } else { /* if port wasn't given, we can try and search * for available sockets */ if (mero_port == -1) { DIR *d; struct dirent *e; struct stat s; d = opendir(mero_host); if (d == NULL) { fprintf(stderr, "monetdb: cannot find a control socket, use -h and/or -p\n"); exit(1); } while ((e = readdir(d)) != NULL) { if (strncmp(e->d_name, ".s.merovingian.", 15) != 0) continue; snprintf(buf, sizeof(buf), "%s/%s", mero_host, e->d_name); if (stat(buf, &s) == -1) continue; if (S_ISSOCK(s.st_mode)) { if (control_ping(buf, -1, NULL) == 0) { mero_host = buf; break; } } } closedir(d); } } if (mero_host != buf) { fprintf(stderr, "monetdb: cannot find a control socket, use -h and/or -p\n"); exit(1); } /* don't confuse control_send lateron */ mero_port = -1; } /* for TCP connections */ if (mero_host != NULL && *mero_host != '/' && mero_port == -1) mero_port = 50000; /* handle regular commands */ if (strcmp(argv[i], "create") == 0) { command_create(argc - i, &argv[i]); } else if (strcmp(argv[i], "destroy") == 0) { command_destroy(argc - i, &argv[i]); } else if (strcmp(argv[i], "lock") == 0) { command_lock(argc - i, &argv[i]); } else if (strcmp(argv[i], "release") == 0) { command_release(argc - i, &argv[i]); } else if (strcmp(argv[i], "status") == 0) { command_status(argc - i, &argv[i]); } else if (strcmp(argv[i], "start") == 0) { command_startstop(argc - i, &argv[i], START); } else if (strcmp(argv[i], "stop") == 0) { command_startstop(argc - i, &argv[i], STOP); } else if (strcmp(argv[i], "kill") == 0) { command_startstop(argc - i, &argv[i], KILL); } else if (strcmp(argv[i], "set") == 0) { command_set(argc - i, &argv[i], SET); } else if (strcmp(argv[i], "get") == 0) { command_get(argc - i, &argv[i]); } else if (strcmp(argv[i], "inherit") == 0) { command_set(argc - i, &argv[i], INHERIT); } else if (strcmp(argv[i], "discover") == 0) { command_discover(argc - i, &argv[i]); } else { fprintf(stderr, "monetdb: unknown command: %s\n", argv[i]); command_help(0, NULL); } if (mero_pass != NULL) free(mero_pass); return(0); }