void trivia_update(void)
{
CHAR_DATA *ch = 0;
char buf[MAX_STRING_LENGTH];
HINT *hint;
if(!trivia[1])
return;
trivia[1] -= 5;
if(trivia[1] <= 0)
{
if(!trivia_winner)
{
sprintf(buf, "Info-> The trivia has ended with no one guessing the correct answer.\n\r");
}
else
{
sprintf(buf, "Info-> %s has guessed the correct trivia answer and is awarded %li quest points!\n\r",
trivia_winner, trivia_reward);
if(winner && !IS_NPC(winner))
winner->pcdata->quest += trivia_reward;
}
do_echo(char_list, buf);
if(!trivia_winner || IS_IMMORTAL(winner))
{
if((ch = get_char_world(char_list, trivia_char)) != 0)
{
sprintf(buf, "You get your %li quest points back.\n\r", trivia_reward);
send_to_char(buf, ch);
ch->pcdata->quest += trivia_reward;
buf[0] = '\0';
}
}
sprintf(buf + strlen(buf), "Info-> The question was [%s]\n\r"
"Info-> The answer was [%s]\n\r"
"Info-> Creator of the trivia was [%s]\n\r"
"Info-> You had [%li] minutes, there is %li seconds left, and there were [%li] guesses.\n\r",
trivia_question, trivia_answer, trivia_char, trivia[0], trivia_timeleft, guesses);
for(hint = hint_list; hint; hint = hint->next)
sprintf(buf + strlen(buf), "Info-> Hint: %s.\n\r", hint->hint);
if(char_list)
do_echo(char_list, buf);
write_trivia();
trivia[1] = 0;
winner = 0;
return;
}
}
int main( void )
{
int connfd;
int listenfd;
socklen_t len;
struct sockaddr_in saddr;
struct sockaddr_in caddr;
memset(&saddr, 0x00, sizeof(saddr));
memset(&caddr, 0x00, sizeof(caddr));
if ( (listenfd=socket(PF_INET, SOCK_STREAM, 0)) == -1)
ERR_EXIT("socket");
saddr.sin_family = AF_INET;
saddr.sin_port = htons(10000);
inet_aton("192.168.0.200", &saddr.sin_addr);
len = sizeof(saddr);
if ( bind(listenfd, (struct sockaddr*)&saddr, len) == -1)
ERR_EXIT("bind");
if ( listen(listenfd, SOMAXCONN) == -1)
ERR_EXIT("listen");
len = sizeof(caddr);
connfd = accept(listenfd, (struct sockaddr*)&caddr, &len);
if ( connfd == -1 ) ERR_EXIT("accept");
do_echo(connfd);
close(connfd);
close(listenfd);
return 0;
}
//=============================main function==========================
int main(int argc,char *argv[])
{
int sockfd;
struct sockaddr_in servaddr,cliaddr;
// create a socket, using the UDP
sockfd = socket(AF_INET,SOCK_DGRAM,0);
// init servaddr
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=INADDR_ANY;
servaddr.sin_port=htons(SERV_PORT);
// bind address and port to socket
if (bind(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr))==-1)
{
perror("bind error,the ip address is wrong");
exit(1);
}
do_echo(sockfd,(struct sockaddr*)&cliaddr,sizeof(cliaddr));
return 0;
}
static void *thread_console(void *arg) {
if (ab_manage(STDIN_FILENO) == -1 || ab_manage(STDOUT_FILENO) == -1)
return (void *) (intptr_t) errno;
do_echo(STDIN_FILENO, STDOUT_FILENO);
exit(0);
}
void do_addchange( CHAR_DATA * ch, char *argument )
{
CHANGE_DATA *new_table;
char arg1[MAX_INPUT_LENGTH];
char buf[MSL];
argument = one_argument( argument, arg1 );
if( IS_NPC( ch ) )
return;
if( argument[0] == '\0' )
{
send_to_char( "Syntax: Addchange <type> <string>\n\r", ch );
send_to_char( "#wTypes are: code, area, help, rule, typo.#n\n\r", ch );
send_to_char( "#wType '#Rchanges#w' to view the list.#n\n\r", ch );
return;
}
/*
* Addchange must have an argument now - Zarius
*/
if( str_cmp( arg1, "code" ) && str_cmp( arg1, "area" ) && str_cmp( arg1, "help" ) && str_cmp( arg1, "rule" )
&& str_cmp( arg1, "typo" ) )
{
send_to_char( "Incorrect Type! Must be code, area, help, rule or typo ONLY\n\r", ch );
return;
}
if( strlen( argument ) < 10 )
{
send_to_char( "The change description must be longer than 10 chars.\n\r", ch );
return;
}
maxChanges++;
new_table = ( CHANGE_DATA * ) realloc( changes_table, sizeof( CHANGE_DATA ) * ( maxChanges + 1 ) );
if( !new_table ) /* realloc failed */
{
send_to_char( "Memory allocation failed. Brace for impact.\n\r", ch );
return;
}
changes_table = new_table;
changes_table[maxChanges - 1].change = str_dup( argument );
changes_table[maxChanges - 1].coder = str_dup( ch->name );
changes_table[maxChanges - 1].date = str_dup( current_date( ) );
changes_table[maxChanges - 1].type = str_dup( capitalize( arg1 ) );
changes_table[maxChanges - 1].mudtime = current_time;
send_to_char( "Changes Created.\n\r", ch );
send_to_char( "Type 'changes' to see the changes.\n\r", ch );
xprintf( buf, "#D<#CCHANGE#D> #w%s change #R##%d #wadded, type '#Rchanges#w' to see the details.#D\n\r",
capitalize( arg1 ), maxChanges );
do_echo( ch, buf );
save_changes( );
return;
}
int main(void){
int ret = -1;
/*Init Led port*/
if((ret = exportGPIOPin(led0.pin)) == -1){
printf("exportGPIO(%d)failed\n", led0.pin);
}
if((ret = setGPIODirection(led0.pin, GPIO_OUT)) == -1){
printf("setGPIODirection(%d)failed\n", led0.pin);
}
if((sockfd = socket(AF_INET, SOCK_STREAM,0))==-1){
perror("socket");
exit(1);
};
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
if(bind(sockfd, (struct sockaddr *)&servaddr,sizeof(servaddr)) == -1){
perror("bind error");
exit(1);
}
if(listen(sockfd,10)<0){
perror("listen");
exit(1);
}
do_echo(sockfd);
return 0;
}
void do_echo_command(int sock_cli, char *buf, sockaddr_in *serv, hostent *he, sockaddr_in client) {
char cmd[4];
int sock;
cmd[0] = buf[0];
cmd[1] = buf[1];
cmd[2] = buf[2];
cmd[3] = '\0';
if(!strcmp(cmd, "add")) {
if(do_echo(&sock, buf, serv, he, 0)) {
enviar(sock_cli, "Cadastrado com Sucesso!\n");
} else {
enviar(sock_cli, "Erro no Cadastramento!\n");
}
close(sock);
return;
}
int sock1, sock2, opcao = 0;
char *f, *g, *h;
if(!strcmp(cmd, "bus")) opcao = 1;
if(!fork()) {
if(!fork()) { //server1
do_rem_bus(opcao, sock_cli, f, &sock, buf, serv, he, 9990);
exit(0);
} //server2
do_rem_bus(opcao, sock_cli, g, &sock1, buf, serv, he, 9991);
while(wait(NULL) > 0);
exit(0);
} //server3
do_rem_bus(opcao, sock_cli, h, &sock2, buf, serv, he, 9992);
while(wait(NULL) > 0);
}
static ErlDrvSSizeT control(ErlDrvData drvstate, unsigned int command,
char *args, ErlDrvSizeT argslen,
char **rbuf, ErlDrvSizeT rbuflen) {
state *st = (state *)drvstate;
init_state(st, args, argslen);
switch (command) {
case ENDWIN: do_endwin(st); break;
case INITSCR: do_initscr(st); break;
case REFRESH: do_refresh(st); break;
case CBREAK: do_cbreak(st); break;
case NOCBREAK: do_nocbreak(st); break;
case ECHO: do_echo(st); break;
case NOECHO: do_noecho(st); break;
case ADDCH: do_addch(st); break;
case ADDSTR: do_addstr(st); break;
case MOVE: do_move(st); break;
case GETYX: do_getyx(st); break;
case GETMAXYX: do_getmaxyx(st); break;
case CURS_SET: do_curs_set(st); break;
case WERASE: do_werase(st); break;
case HAS_COLORS: do_has_colors(st); break;
case START_COLOR: do_start_color(st); break;
case INIT_PAIR: do_init_pair(st); break;
case WATTRON: do_wattron(st); break;
case WATTROFF: do_wattroff(st); break;
case NL: do_nl(st); break;
case NONL: do_nonl(st); break;
case SCROLLOK: do_scrollok(st); break;
case MVADDCH: do_mvaddch(st); break;
case MVADDSTR: do_mvaddstr(st); break;
case NEWWIN: do_newwin(st); break;
case DELWIN: do_delwin(st); break;
case WMOVE: do_wmove(st); break;
case WADDSTR: do_waddstr(st); break;
case WADDCH: do_waddch(st); break;
case MVWADDSTR: do_mvwaddstr(st); break;
case MVWADDCH: do_mvwaddch(st); break;
case WREFRESH: do_wrefresh(st); break;
case WHLINE: do_whline(st); break;
case WVLINE: do_wvline(st); break;
case WBORDER: do_wborder(st); break;
case BOX: do_box(st); break;
case KEYPAD: do_keypad(st); break;
default: break;
}
int rlen = st->eixb.index;
ErlDrvBinary *response = driver_alloc_binary(rlen);
memcpy(response->orig_bytes, st->eixb.buff, rlen);
ei_x_free(&(st->eixb));
*rbuf = (char *)response;
return rlen;
}
void do_rem_bus(int opcao, int sock_cli, char *cmp, int *sock, char *buf, sockaddr_in *serv, hostent *he, int port) {
if(!do_echo(sock, buf, serv, he, port)) return;
receber(sock, cmp, 400);
if(strcmp(cmp, "end")) {
enviar(sock_cli, cmp);
if(opcao) {
while(strcmp(cmp, "end")) {
receber(sock, cmp, 400);
enviar(sock_cli, cmp);
}
}
}
}
int
main(int argc, char *argv[])
{
qb_ipcc_connection_t *conn;
const char *options = "eb";
int32_t opt;
while ((opt = getopt(argc, argv, options)) != -1) {
switch (opt) {
case 'b':
do_benchmark = QB_TRUE;
break;
case 'e':
use_events = QB_TRUE;
break;
case 'h':
default:
show_usage(argv[0]);
exit(0);
break;
}
}
qb_log_init("ipcclient", LOG_USER, LOG_TRACE);
qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);
qb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_ADD,
QB_LOG_FILTER_FILE, "*", LOG_TRACE);
qb_log_format_set(QB_LOG_STDERR, "%f:%l [%p] %b");
qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
/* Our example server is enforcing a buffer size minimum,
* so the client does not need to be concerned with setting
* the buffer size */
conn = qb_ipcc_connect("ipcserver", 0);
if (conn == NULL) {
perror("qb_ipcc_connect");
exit(1);
}
data = calloc(1, qb_ipcc_get_buffer_size(conn));
if (do_benchmark) {
do_throughput_benchmark(conn);
} else {
do_echo(conn);
}
qb_ipcc_disconnect(conn);
free(data);
return EXIT_SUCCESS;
}
int main(int argc, char * argv[]) {
if (argc < 1) {
fprintf(stderr, "%s: file name not given\n", argv[0]);
exit(1);
}
if (argc == 1) {
do_echo();
} else {
for (int i = 1; i < argc; i++) {
do_cat(argv[i]);
}
}
exit(0);
}
int main(int argc, char **argv)
{
int sock, ret;
int connfd;
int socklen;
int childpid=0;
struct sockaddr_in server_addr, client_addr;
sock = socket(AF_INET, SOCK_STREAM, 0);
CHECK_FAILED((-1 == sock), "socket error, ");
TRACE("%d\n", sock);
// memset(&addr, 0, sizeof(struct sockaddr_in));
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(SERVER_PORT);
ret = bind(sock, (const struct sockaddr*)&server_addr, sizeof(server_addr));
CHECK_FAILED((-1 == ret), "bind error, ");
TRACE("(bind): %d\n", ret);
ret = listen(sock, LISTENQ);
CHECK_FAILED((-1 == ret), "listen error, ");
TRACE("(listen): %d\n", ret);
for(;;) {
socklen = sizeof(client_addr);
printf("[%d] wait request\n", getpid());
connfd = accept(sock, (struct sockaddr*)&client_addr, &socklen);
CHECK_FAILED((-1 == connfd), "accept error, ");
if((childpid = fork()) == 0 )
{
printf("[%d] accept Request at %d.\n", getpid(), connfd);
close(sock);
do_echo(connfd);
exit(0);
}
CHECK_FAILED((childpid < 0), "fork error, ");
close(connfd);
}
return 0;
}
static void
server_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *context, gpointer data)
{
char *method_name;
SoupXMLRPCParams *params;
GError *error = NULL;
if (msg->method != SOUP_METHOD_POST) {
soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
soup_message_set_status (msg, SOUP_STATUS_OK);
method_name = soup_xmlrpc_parse_request (msg->request_body->data,
msg->request_body->length,
¶ms, &error);
if (!method_name) {
soup_xmlrpc_message_set_fault (msg, SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED,
"Could not parse method call: %s", error->message);
g_clear_error (&error);
return;
}
if (!strcmp (method_name, "sum"))
do_sum (msg, params);
else if (!strcmp (method_name, "countBools"))
do_countBools (msg, params);
else if (!strcmp (method_name, "md5sum"))
do_md5sum (msg, params);
else if (!strcmp (method_name, "dateChange"))
do_dateChange (msg, params);
else if (!strcmp (method_name, "echo"))
do_echo (msg, params);
else if (!strcmp (method_name, "ping"))
do_ping (msg, params);
else {
soup_xmlrpc_message_set_fault (msg, SOUP_XMLRPC_FAULT_SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND,
"Unknown method %s", method_name);
}
g_free (method_name);
soup_xmlrpc_params_free (params);
}
int
main(int argc, char *argv[])
{
qb_ipcc_connection_t *conn;
const char *options = "eb";
int32_t opt;
while ((opt = getopt(argc, argv, options)) != -1) {
switch (opt) {
case 'b':
do_benchmark = QB_TRUE;
break;
case 'e':
use_events = QB_TRUE;
break;
case 'h':
default:
show_usage(argv[0]);
exit(0);
break;
}
}
qb_log_init("ipcclient", LOG_USER, LOG_TRACE);
qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);
qb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_ADD,
QB_LOG_FILTER_FILE, "*", LOG_TRACE);
qb_log_format_set(QB_LOG_STDERR, "%f:%l [%p] %b");
qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
conn = qb_ipcc_connect("ipcserver", MAX_MSG_SIZE);
if (conn == NULL) {
perror("qb_ipcc_connect");
exit(1);
}
if (do_benchmark) {
do_throughput_benchmark(conn);
} else {
do_echo(conn);
}
qb_ipcc_disconnect(conn);
return EXIT_SUCCESS;
}
int main(int argc, char** argv)
{
struct configuration cfg;
int sock;
unsigned int pkt_num = 0;
parse_options(argc, argv, &cfg);
/* Initialise */
sock = add_socket(&cfg);
do_mcast(&cfg, sock);
do_ioctl(&cfg, sock);
do_ts_sockopt(&cfg, sock);
/* Run until we've got enough packets, or an error occurs */
while( (pkt_num++ < cfg.cfg_max_packets) || (cfg.cfg_max_packets == 0) )
TRY( do_echo(sock, pkt_num, cfg.cfg_templated) );
close(sock);
return 0;
}
int my_echo(t_shell *shell, char **cmd)
{
t_echo *echo;
int i;
(void)shell;
if ((echo = my_xmalloc(sizeof(*echo))) == NULL)
return (-1);
echo->opt_n = 0;
echo->opt_e = 0;
i = 1;
while (cmd[i] != NULL)
{
i = get_opt_n(cmd, i, echo);
i = get_opt_e(cmd, i, echo);
i++;
}
if (do_echo(cmd, echo) == -1)
return (-1);
if (echo->opt_n != 1)
my_putchar('\n');
return (0);
}
static void *thread_tcp_handler(void *v_fd) {
int fd = (int) (intptr_t) v_fd,
rc;
struct sockaddr_in addr;
socklen_t addr_len = sizeof(struct sockaddr_in);
char addr_text[20] = {0};
rc = getpeername(fd, (struct sockaddr *) &addr, &addr_len);
inet_ntop(AF_INET, &addr.sin_addr, addr_text, sizeof(addr_text));
printf("[%s]Connected\n", addr_text);
if (rc < 0) {
fprintf(stderr, "Fail to getpeername on %d\n", fd);
return (void *) (intptr_t) errno;
}
rc = do_echo(fd, fd);
ab_shutdown(fd, SHUT_RDWR);
ab_close(fd);
fprintf(stdout, "[%s]Disconnected\n", addr_text);
return (void *) (intptr_t) rc;
}
int main(int argc, char **argv)
{
int sockfd, n;
struct sockaddr_in servaddr;
statusfd = fileno(stdout);
if (argc < 2)
show_err_sys("usage: echo_cli <IPaddress> [statusfd]");
if(argc > 2) {
statusfd = atoi(argv[2]);
}
if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
show_err_sys("socket error");
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(7161);
if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {
fprintf(fdopen(statusfd, "w+"), "inet_pton error for %s\n", argv[1]);
exit(0);
}
if (connect(sockfd, (SA *) &servaddr, sizeof(servaddr)) < 0)
show_err_sys("connect error");
n = write(statusfd, "Echo Client Started", 20);
printf("Welcome to echo client!!!\n");
do_echo(stdin, sockfd);
close(sockfd);
}
void do_trivia(CHAR_DATA * ch, char *argument)
{
TRIVIA *s_trivia;
HINT *hint, *hint_next;
char buf[MAX_STRING_LENGTH];
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char question[MAX_QUESTION_LENGTH];
char answer[MAX_ANSWER_LENGTH];
char reward[MAX_STRING_LENGTH];
long i = 0;
long len;
long num = 0;
long words = 1;
argument = one_argument(argument, arg1);
one_argument(argument, arg2);
if(arg1[0] == '\0')
{
if(trivia[1])
{
sprintf(buf, "The question is [%s]\n\r"
"The answer is %li words and the reward is %li points.\n\r"
"There are roughly %li seconds left to guess.\n\r",
trivia_question, trivia_words, trivia_reward, trivia[1]);
for(hint = hint_list; hint; hint = hint->next)
sprintf(buf + strlen(buf), "Hint: %s.\n\r", hint->hint);
send_to_char(buf, ch);
return;
}
send_to_char("There is no trivia going on at this time.\n\r", ch);
return;
}
if(!str_cmp(arg1, "show"))
{
TRIVIA *t_start = trivia_list;
if(arg2[0] == '\0')
{
num = 0;
}
else
{
num = atoi(arg2);
}
for(i = 0; i < num; i++)
{
buf[0] = '\0';
for(s_trivia = t_start; s_trivia; s_trivia = s_trivia->next)
{
if(strlen(buf) > MAX_STRING_LENGTH - 250)
{
t_start = s_trivia;
break;
}
sprintf(buf + strlen(buf), "[Q:%s] [A:%s]\n\r"
"[Creator:%s] [Winner:%s] [Guesses:%li] [Time:%li] [Time left:%li] [Reward:%li]\n\r",
s_trivia->question,
s_trivia->answer,
s_trivia->character,
s_trivia->winner,
s_trivia->guesses, s_trivia->time, s_trivia->timeleft, s_trivia->reward);
for(hint = s_trivia->hints; hint; hint = hint->next)
sprintf(buf + strlen(buf), "..Hint: %s.\n\r", hint->hint);
sprintf(buf + strlen(buf), "\n\r");
}
}
buf[0] = '\0';
for(s_trivia = trivia_list; s_trivia; s_trivia = s_trivia->next)
{
if(strlen(buf) > MAX_STRING_LENGTH - 250)
{
sprintf(buf + strlen(buf), "File is too large. Type trivia show %li to view rest.\n\r",
num + 1);
break;
}
sprintf(buf + strlen(buf), "[Q:%s] [A:%s]\n\r"
"[Creator:%s] [Winner:%s] [Guesses:%li] [Time:%li] [Time left:%li] [Reward:%li]\n\r",
s_trivia->question,
s_trivia->answer,
s_trivia->character,
s_trivia->winner, s_trivia->guesses, s_trivia->time, s_trivia->timeleft, s_trivia->reward);
for(hint = s_trivia->hints; hint; hint = hint->next)
sprintf(buf + strlen(buf), "..Hint: %s.\n\r", hint->hint);
sprintf(buf + strlen(buf), "\n\r");
}
send_to_char(buf, ch);
return;
}
if(!str_cmp(arg1, "answer") || !str_cmp(arg1, "guess"))
{
if(!trivia[1] || argument[0] == '\0')
{
send_to_char("42.\n\r", ch);
return;
}
if(!str_cmp(trivia_char, ch->name))
{
send_to_char("Something smells fishy.\n\r", ch);
return;
}
guesses++;
if(str_cmp(argument, trivia_answer))
{
send_to_char("Sorry, that's wrong.\n\r", ch);
return;
}
if(trivia_winner)
{
send_to_char("That's absolutely RIGHT!\n\r", ch);
send_to_char("But someone beat you to it...\n\r", ch);
return;
}
/* wow he got it */
send_to_char("That's absolutely RIGHT!\n\r", ch);
trivia_winner = str_dup(ch->name);
trivia_timeleft = trivia[1];
trivia[1] = 1; /* set timer to 0 */
winner = ch;
return;
}
if(!str_cmp(arg1, "question") && (IS_IMMORTAL(ch) || player_trivia))
{
if(trivia[1])
{
send_to_char("There is already a trivia going on.\n\r", ch);
return;
}
/* players must supply QP amount for rewared */
if(!IS_IMMORTAL(ch))
{
argument = one_argument(argument, reward);
if(!is_number(reward))
{
send_to_char("You must supply a reward amount to do trivia.\n\r", ch);
return;
}
i = atoi(reward);
if(i < 0 || i > 100)
{
send_to_char("Reward must be from 0 to 100.\n\r", ch);
return;
}
if(ch->pcdata->quest < i)
{
send_to_char("You don't have that many Quest Points.\n\r", ch);
return;
}
trivia_reward = i;
ch->pcdata->quest -= i;
i = 0;
}
if(argument[0] == '\0' || (len = strlen(argument)) < 5 || !strstr(argument, "?"))
{
send_to_char("You must supply a valid question and answer.\n\r", ch);
return;
}
/* parse question */
while(i < len && *argument != '?' && i < MAX_QUESTION_LENGTH)
question[i++] = *argument++;
if(i < MAX_QUESTION_LENGTH - 1)
question[i++] = *argument++; /* add the question mark */
if(i == MAX_QUESTION_LENGTH)
{
sprintf(buf, "The question is limited to %d characters long.\n\r", MAX_QUESTION_LENGTH);
send_to_char(buf, ch);
return;
}
question[i] = '\0';
if(i == len)
{
send_to_char("You must supply an answer!\n\r", ch);
return;
}
i = 0;
while(isspace(*argument)) /* get rid of spaces after question mark */
argument++;
while(i < len && i < MAX_ANSWER_LENGTH && *argument != '\0')
{
if(isspace(*argument))
words++;
answer[i++] = *argument++;
}
if(i == MAX_ANSWER_LENGTH)
{
sprintf(buf, "Answers are limited to %d characters long.\n\r", MAX_ANSWER_LENGTH);
send_to_char(buf, ch);
return;
}
answer[i] = '\0';
trivia[1] = trivia[0] * 60; /* minutes */
trivia_char = str_dup(ch->name);
trivia_question = str_dup(question);
trivia_answer = str_dup(answer);
trivia_words = words;
guesses = 0;
sprintf(buf, "Info-> %s has started a trivia! The question is [%s]\n\r"
"Info-> The answer consists of %li words.\n\r"
"Info-> You have %li minutes to guess the answer.\n\r", ch->name, question, trivia_words, trivia[0]);
if(!IS_IMMORTAL(ch))
{
sprintf(buf + strlen(buf), "Info-> The reward for the trivia is %li Quest Points.\n\r",
trivia_reward);
}
do_echo(ch, buf);
return;
}
if(IS_IMMORTAL(ch) || (!str_cmp(trivia_char, ch->name)))
{
if(!str_cmp(arg1, "hint"))
{
if(trivia[1] <= 0)
{
send_to_char("There is no trivia going on.\n\r", ch);
return;
}
if(argument[0] == '\0')
{
send_to_char("You must include the hint!\n\r", ch);
return;
}
hint = alloc_mem(sizeof(*hint), "trivia hint");
hint->hint = str_dup(argument);
hint->next = hint_list;
hint_list = hint;
sprintf(buf, "Info-> %s adds a hint: %s.", ch->name, argument);
do_echo(ch, buf);
return;
}
if(!str_cmp(arg1, "cancel"))
{
trivia[1] = 0;
free_string(trivia_question);
free_string(trivia_char);
free_string(trivia_answer);
if(trivia_winner)
free_string(trivia_winner);
for(hint = hint_list; hint; hint = hint_next)
{
hint_next = hint->next;
free_mem(hint, sizeof(HINT));
}
sprintf(buf, "Info-> The trivia has been canceled by %s.\n\r", ch->name);
do_echo(ch, buf);
return;
}
}
if(IS_IMMORTAL(ch))
{
if(!str_cmp(arg1, "reward"))
{
long reward;
if(argument[0] == '\0' || !is_number(argument))
{
send_to_char("Second argument must be a number.\n\r", ch);
return;
}
reward = atoi(argument);
if(reward < 0 || reward > 100)
{
send_to_char("Reward amount ranges from 0 to 100.\n\r", ch);
return;
}
trivia_reward = reward;
sprintf(buf, "Info-> %s changes the reward amount to %li points for trivia.\n\r",
ch->name, trivia_reward);
do_echo(ch, buf);
return;
}
if(!str_cmp(arg1, "time"))
{
long time;
if(argument[0] == '\0' || !is_number(argument))
{
send_to_char("You must supply an integer.\n\r", ch);
return;
}
time = atoi(argument);
if(time < 0 || time > 5)
{
send_to_char("I think 5 minutes is plenty of time.\n\r", ch);
return;
}
trivia[0] = time;
send_to_char("Ok.\n\r", ch);
return;
}
if(!str_cmp(arg1, "player"))
{
if(argument[0] == '\0')
{
send_to_char("Must be on or off.\n\r", ch);
return;
}
if(!str_cmp(argument, "on"))
{
player_trivia = 1;
do_info(char_list, "Players may start trivia now!\n\r");
send_to_char("Players may start trivia now.\n\r", ch);
return;
}
if(!str_cmp(argument, "off"))
{
player_trivia = 0;
do_info(char_list, "Players can no longer start trivia.\n\r");
send_to_char("Players may not start trivia now.\n\r", ch);
return;
}
send_to_char("Syntax: trivia player <on/off>\n\r", ch);
return;
}
}
send_to_char("Syntax: trivia\n\r", ch);
send_to_char("or trivia show\n\r", ch);
send_to_char("or trivia guess <answer>\n\r", ch);
send_to_char("or trivia question <question + ?> <answer>\n\r", ch);
if(IS_IMMORTAL(ch))
{
send_to_char("or trivia hint <hint>\n\r", ch);
send_to_char("or trivia reward <reward>\n\r", ch);
send_to_char("or trivia player <on/off>\n\r", ch);
send_to_char("or trivia cancel\n\r", ch);
}
send_to_char("You must supply the question mark for the question.\n\r\n\r", ch);
send_to_char("Do not include any punctuation for the answer, it must be a direct match.\n\r", ch);
return;
}
void do_admin_command(caValue* input, caValue* reply)
{
// Identify the command
int first_space = string_find_char(input, 0, ' ');
if (first_space == -1)
first_space = string_length(input);
Value command;
string_slice(input, 0, first_space, &command);
set_null(reply);
if (equals_string(&command, "add_lib_path")) {
//List args;
//parse_tokens_as_argument_list(&tokens, &args);
} else if (equals_string(&command, "file")) {
List args;
parse_string_as_argument_list(input, &args);
do_file_command(&args, reply);
} else if (equals_string(&command, "echo")) {
List args;
parse_string_as_argument_list(input, &args);
do_echo(&args, reply);
} else if (equals_string(&command, "write_block")) {
int nextSpace = string_find_char(input, first_space+1, ' ');
if (nextSpace == -1) {
set_string(reply, "Syntax error, not enough arguments");
return;
}
Value blockName;
string_slice(input, first_space+1, nextSpace, &blockName);
Value contents;
string_slice(input, nextSpace+1, -1, &contents);
do_write_block(&blockName, &contents, reply);
} else if (equals_string(&command, "update_file")) {
int nextSpace = string_find_char(input, first_space+1, ' ');
if (nextSpace == -1) {
set_string(reply, "Syntax error, not enough arguments");
return;
}
Value filename;
string_slice(input, first_space+1, nextSpace, &filename);
Value contents;
string_slice(input, nextSpace+1, -1, &contents);
do_update_file(&filename, &contents, reply);
} else if (equals_string(&command, "source_repro")) {
List args;
parse_string_as_argument_list(input, &args);
Block block;
load_script(&block, as_cstring(args[1]));
std::cout << get_block_source_text(&block);
} else if (equals_string(&command, "dump_stats")) {
perf_stats_dump();
std::cout << ":done" << std::endl;
} else {
set_string(reply, "Unrecognized command: ");
string_append(reply, &command);
}
}
/*
* Generic channel function.
*/
void talk_channel( CHAR_DATA *ch, char *argument, int channel, const char *verb )
{
char buf[MAX_STRING_LENGTH];
DESCRIPTOR_DATA *d;
int position;
char *color = "&n";
if ( ch && argument[0] == '\0' )
{
sprintf( buf, "%s what?\n\r", verb );
buf[0] = UPPER(buf[0]);
return;
}
if ( ch && !IS_NPC(ch) && IS_SET(ch->act, PLR_SILENCE) )
{
sprintf( buf, "You can't %s.\n\r", verb );
send_to_char( buf, ch );
return;
}
if( ch )
REMOVE_BIT(ch->deaf, channel);
switch( channel ) /* for colors only */
{
case CHANNEL_CHAT: color = "&+m"; break;
case CHANNEL_SHOUT: color = "&+Y"; break;
case CHANNEL_YELL: color = "&+y"; break;
case CHANNEL_MUSIC: color = "&+M"; break;
default: break;
}
switch ( channel )
{
default:
sprintf( buf, "%sYou %s '%s&n%s'.\n\r", color, verb, argument, color );
send_to_char( buf, ch );
sprintf( buf, "%s$n %ss '$t&n%s'.", color, verb, color );
break;
case CHANNEL_WARMESSAGE:
sprintf( buf, "**** %s ****", argument );
do_echo( ch, buf );
return;
case CHANNEL_IMMTALK:
sprintf( buf, "&+c$n: $t." );
position = ch->position;
ch->position = POS_STANDING;
act( buf, ch, argument, NULL, TO_CHAR );
ch->position = position;
break;
}
for ( d = descriptor_list; d != NULL; d = d->next )
{
CHAR_DATA *och;
CHAR_DATA *vch;
och = d->original ? d->original : d->character;
vch = d->character;
if ( d->connected == CON_PLAYING
&& vch != ch
&& !IS_SET(och->deaf, channel) )
{
if ( channel == CHANNEL_IMMTALK && !IS_HERO(och) )
continue;
if ( channel == CHANNEL_YELL
&& vch->in_room->area != ch->in_room->area )
continue;
position = vch->position;
if ( channel != CHANNEL_SHOUT && channel != CHANNEL_YELL )
vch->position = POS_STANDING;
act( buf, ch, argument, vch, TO_VICT );
vch->position = position;
}
}
return;
}
void
shopping_buy(char *arg, struct char_data *ch,
struct char_data *keeper, int shop_nr)
{
char tempstr[200], buf[MAX_STRING_LENGTH];
struct obj_data *obj, *last_obj = NULL;
int goldamt = 0, buynum, bought = 0;
if (!(is_ok(keeper, ch, shop_nr)))
return;
if (SHOP_SORT(shop_nr) < IS_CARRYING_N(keeper))
sort_keeper_objs(keeper, shop_nr);
if ((buynum = transaction_amt(arg)) < 0)
{
sprintf(buf, "%s A negative amount? Try selling me something.",
GET_NAME(ch));
do_tell(keeper, buf, cmd_tell, 0);
return;
}
if (!(*arg) || !(buynum))
{
sprintf(buf, "%s What do you want to buy??", GET_NAME(ch));
do_tell(keeper, buf, cmd_tell, 0);
return;
}
if (!(obj = get_purchase_obj(ch, arg, keeper, shop_nr, TRUE)))
return;
if ((buy_price(ch, obj, shop_nr) > GET_GOLD(ch)) && !IS_GOD(ch))
{
sprintf(buf, shop_index[shop_nr].missing_cash2, GET_NAME(ch));
do_tell(keeper, buf, cmd_tell, 0);
switch (SHOP_BROKE_TEMPER(shop_nr))
{
case 0:
do_action(keeper, GET_NAME(ch), cmd_puke, 0);
return;
case 1:
do_echo(keeper, "smokes on his joint.", cmd_emote, SCMD_EMOTE);
return;
default:
return;
}
}
if ((IS_CARRYING_N(ch) + 1 > CAN_CARRY_N(ch)))
{
sprintf(buf, "%s: You can't carry any more items.\n\r",
fname(obj->name));
send_to_char(buf, ch);
return;
}
if ((IS_CARRYING_W(ch) + GET_OBJ_WEIGHT(obj)) > CAN_CARRY_W(ch))
{
sprintf(buf, "%s: You can't carry that much weight.\n\r",
fname(obj->name));
send_to_char(buf, ch);
return;
}
while ((obj) && ((GET_GOLD(ch) >= buy_price(ch, obj, shop_nr)) || IS_GOD(ch))
&& (IS_CARRYING_N(ch) < CAN_CARRY_N(ch)) && (bought < buynum)
&& (IS_CARRYING_W(ch) + GET_OBJ_WEIGHT(obj) <= CAN_CARRY_W(ch)))
{
bought++;
/* Test if producing shop ! */
if (shop_producing(obj, shop_nr))
obj = read_object(GET_OBJ_RNUM(obj), REAL);
else
{
obj_from_char(obj);
SHOP_SORT(shop_nr)--;
}
obj_to_char(obj, ch);
goldamt += buy_price(ch, obj, shop_nr);
if (!IS_GOD(ch))
GET_GOLD(ch) -= buy_price(ch, obj, shop_nr);
last_obj = obj;
obj = get_purchase_obj(ch, arg, keeper, shop_nr, FALSE);
if (!same_obj(obj, last_obj))
break;
}
if (bought < buynum)
{
if (!obj || !same_obj(last_obj, obj))
sprintf(buf, "%s I only have %d to sell you.", GET_NAME(ch), bought);
else if (GET_GOLD(ch) < buy_price(ch, obj, shop_nr))
sprintf(buf, "%s You can only afford %d.", GET_NAME(ch), bought);
else if (IS_CARRYING_N(ch) >= CAN_CARRY_N(ch))
sprintf(buf, "%s You can only hold %d.", GET_NAME(ch), bought);
else if (IS_CARRYING_W(ch) + GET_OBJ_WEIGHT(obj) > CAN_CARRY_W(ch))
sprintf(buf, "%s You can only carry %d.", GET_NAME(ch), bought);
else
sprintf(buf, "%s Something screwy only gave you %d.", GET_NAME(ch),
bought);
do_tell(keeper, buf, cmd_tell, 0);
}
if (!IS_GOD(ch))
GET_GOLD(keeper) += goldamt;
sprintf(tempstr, "%s", times_message(ch->carrying, 0, bought));
sprintf(buf, "$n buys %s.", tempstr);
act(buf, FALSE, ch, obj, 0, TO_ROOM);
sprintf(buf, shop_index[shop_nr].message_buy, GET_NAME(ch), goldamt);
do_tell(keeper, buf, cmd_tell, 0);
sprintf(buf, "You now have %s.\n\r", tempstr);
send_to_char(buf, ch);
if (SHOP_USES_BANK(shop_nr))
if (GET_GOLD(keeper) > MAX_OUTSIDE_BANK)
{
SHOP_BANK(shop_nr) += (GET_GOLD(keeper) - MAX_OUTSIDE_BANK);
GET_GOLD(keeper) = MAX_OUTSIDE_BANK;
}
}
int cmd_echoerr(char *param)
{ return do_echo(param, displayError);
}
int cmd_echo(char *param)
{ return do_echo(param, displayString);
}
int do_redirection(char *input) //redircetion
{
char *command_path,*real_command;
char *out_filename,*in_filename;
char **parsed_command;
int len,status,i,j,k,back=0,fd_out=0,fd_in=0,flag_out=0,flag_in=0;
pid_t pid;
back=is_back(input);
len=strlen(input);
out_filename=(char *)malloc((len+1)*(sizeof(char)));
in_filename=(char *)malloc((len+1)*(sizeof(char)));
real_command=(char *)malloc((len+1)*(sizeof(char)));
for(i=0; i<len; i++)
{
if (input[i]!='>' && input[i]!='<')
real_command[i]=input[i];
else
{
if (input[i]=='>')
flag_out=1;
if (input[i]=='<')
flag_in=1;
break;
}
}
real_command[i]='\0';
i++;
if(flag_out==1 && input[i]=='>')
{
flag_out=2;
i++;
}
else if (flag_in==1 && input[i]=='<')
{
flag_in=2;
i++;
}
while ((input[i]==' ' || input[i]==' ') && i<len)
i++;
j=0;
out_filename[0]='\0';
in_filename[0]='\0';
if(flag_out>0)
{
while (i<=len)
{
if(input[i]=='<')
{
out_filename[j]='\0';
break;
}
out_filename[j]=input[i];
i++;
j++;
}
}
if(flag_in>0)
{
while (i<=len)
{
if (input[i]=='>')
{
in_filename[j]='\0';
break;
}
in_filename[j]=input[i];
i++;
j++;
}
}
if (i<len)
{
j=0;
if (flag_out>0 && input[i]=='<')
{
i++;
flag_in=1;
if(input[i]=='>')
{
flag_in=2;
i++;
}
while ((input[i]==' ' || input[i]==' ') && i<len)
i++;
while (i<=len)
{
in_filename[j]=input[i];
i++;
j++;
}
}
else if (flag_in>0 && input[i]=='>')
{
i++;
flag_out=1;
if(input[i]=='>')
{
flag_out=2;
i++;
}
while ((input[i]==' ' || input[i]==' ') && i<len)
i++;
while (i<=len)
{
out_filename[j]=input[i];
i++;
j++;
}
}
else
{
fprintf(stderr,"ERROR!can't find the file!\n");
return -1;
}
}
//for debug
/*printf("real_command: %s\n",real_command);
printf("out_filename: %s\n",out_filename);
printf("in_filename: %s\n",in_filename);*/
k=number(real_command);
parsed_command=parse(real_command);
if(strcmp(parsed_command[0],"cd")==0 || strcmp(parsed_command[0], "echo") == 0 || strcmp(parsed_command[0], "viewproc") == 0 || strcmp(parsed_command[0], "time")==0) //build-in functions
{
if(strcmp(parsed_command[0], "cd") == 0) //cd
{
do_cd(parsed_command);
}
else if(strcmp(parsed_command[0], "echo") == 0) //echo
{
if (pid=fork() == 0)
{
if(flag_out==1)
fd_out = open(out_filename,O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR );
if(flag_out==2)
fd_out = open(out_filename, O_WRONLY|O_CREAT|O_APPEND, S_IRUSR|S_IWUSR );
if(fd_out==-1)
{
printf("Open out %s error \n", out_filename);
return -1;
}
if(flag_out>0)
{
if(dup2(fd_out, STDOUT_FILENO) == -1)
{
fprintf(stderr,"Redirect Standard Out Error !\n");
exit(1);
}
}
do_echo(real_command);
exit(1);
}
else
{ //parent
if(back==0)
pid=waitpid(pid, &status, 0);
else
pid=waitpid(pid, &status, WNOHANG);
}
}
else if(strcmp(parsed_command[0], "viewproc") == 0) //viewproc
{
if (pid=fork() == 0)
{
if(flag_out==1)
fd_out = open(out_filename,O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR );
if(flag_out==2)
fd_out = open(out_filename, O_WRONLY|O_CREAT|O_APPEND, S_IRUSR|S_IWUSR );
if(fd_out==-1)
{
printf("Open out %s error \n", out_filename);
return -1;
}
if(flag_out>0)
{
if(dup2(fd_out, STDOUT_FILENO) == -1)
{
fprintf(stderr,"Redirect Standard Out Error !\n");
exit(1);
}
}
do_viewproc(parsed_command[1]);
close(flag_out);
exit(1);
}
else
{ //parent
if(back==0)
pid=waitpid(pid, &status, 0);
else
pid=waitpid(pid, &status, WNOHANG);
}
}
else if(strcmp(parsed_command[0], "time") == 0) //time
{
gettimeofday(&tpstart,0);
do_time(real_command);
}
for(i=0;i<k;i++)
free(parsed_command[i]);
free(parsed_command);
free(real_command);
return 1;
}
command_path=is_file_exist(parsed_command[0]);
if(command_path==NULL) //can't find the order
{
fprintf(stderr,"This is command is not founded ?!\n");
// free space
for(i=0;i<k;i++)
free(parsed_command[i]);
free(parsed_command);
free(real_command);
return -1;
}
if((pid = fork()) == 0)
{
if(flag_out==1)
fd_out = open(out_filename,O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR );
if(flag_out==2)
fd_out = open(out_filename, O_WRONLY|O_CREAT|O_APPEND, S_IRUSR|S_IWUSR );
if(flag_in==1)
fd_in = open(in_filename, O_RDONLY, S_IRUSR|S_IWUSR );
if(flag_in==2)
fd_in = open(in_filename, O_RDONLY, S_IRUSR|S_IWUSR );
if(fd_out==-1)
{
printf("Open out %s error \n", out_filename);
return -1;
}
if(fd_in==-1)
{
fprintf(stderr,"Open in %s error \n", in_filename);
return -1;
}
if(flag_out>0)
{
if(dup2(fd_out, STDOUT_FILENO) == -1)
{
fprintf(stderr,"Redirect Standard Out Error !\n");
exit(1);
}
}
if(flag_in>0)
{
if (dup2(fd_in,STDIN_FILENO)==-1)
{
fprintf(stderr,"Redirect Standard Out Error !\n");
exit(1);
}
}
execv(command_path,parsed_command);
exit(1);
}
else
{ //parent
if(back==0)
pid=waitpid(pid, &status, 0);
else
pid=waitpid(pid, &status, WNOHANG);
}
//free space
free(out_filename);
free(in_filename);
free(command_path);
for(i=0;i<k;i++)
free(parsed_command[i]);
free(parsed_command);
return 1;
}
int main(void) {
struct sockaddr_in serv_addr;
int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
linked_fd * fdlist = new_linked_fd();
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_addr.sin_port=htons(5058);
int bind_result = bind(listen_sock,
(struct sockaddr*)&serv_addr, sizeof(serv_addr));
if(bind_result == -1) {
perror("Failed to bind.");
return EXIT_FAILURE;
}
listen(listen_sock, 100);
fd_set fdset;
highest_fd = listen_sock;
do {
FD_ZERO(&fdset);
// Add the listening socket to the fdset.
FD_SET(listen_sock, &fdset);
// Add stdin to the fileset.
FD_SET(STDIN_FILENO, &fdset);
// Add each fd in our fdlist to the set.
linked_fd_node *current = linked_fd_head(fdlist);
while(current) {
int fd = fd_at(current);
if(fd < 0) {
return EXIT_FAILURE;
}
FD_SET(fd, &fdset);
current = linked_fd_next(current);
}
// Select on every fd in the fdset.
int x = select(highest_fd + 1, &fdset, NULL, NULL, NULL);
if(x < 0) {
return EXIT_FAILURE;
}
// If we got something on stdin, close all sockets
// And exit.
if(FD_ISSET(STDIN_FILENO, &fdset)) {
printf("Closing all sockets.\n");
close(listen_sock);
close_all(fdlist);
}
// If the listen_sock is 'ready', accept a socket and
// add it to our fd list.
if(FD_ISSET(listen_sock, &fdset)) {
accept_sock(listen_sock, fdlist);
}
//Handle other fds.
current = linked_fd_head(fdlist);
while(current) {
int fd = fd_at(current);
// This should never happen. Just precautionary.
if(fd < 0) {
return EXIT_FAILURE;
}
if(FD_ISSET(fd, &fdset)) {
do_echo(fd, fdlist);
}
current = linked_fd_next(current);
}
} while(1);
}
void runProcess( Proc *proc, pid_t pgid, int fg, int inputFile, int outputFile, int errorFile)
{
// wrzucenie procesu do grupy procesow i danie przekazanie grupy terminalowu jezeli jest to stosowne
// utowrzenie grupy lub dolaczenie do juz istniejacej
pid_t pid = getpid();
if( pgid == 0 )
pgid = pid;
setpgid(pid, pgid);
// jesli w foreground to oddajemy terminal dla grupy procesow
if(fg == 1)
{
tcsetpgrp( shellTerminal, pgid );
}
struct sigaction act;
act.sa_handler = SIG_DFL; /* set up signal handler */
act.sa_flags = 0;
// kiedy shell przejmuje kontrole, powinien ignorowac ponizsze sygnaly, zeby samemu sie przypadkowo nie killnac
sigaction(SIGINT, &act, NULL);
// powrot do ustawien domyslnych (przez nasz shell te sygnaly byly ignorowane)
sigaction(SIGINT, &act, NULL);
sigaction(SIGQUIT, &act, NULL);
sigaction(SIGCHLD, &act, NULL);
sigaction(SIGTSTP, &act, NULL);
sigaction(SIGTTIN, &act, NULL);
sigaction(SIGTTOU, &act, NULL);
// ustawienie standardowego I/O dla nowego procesu
// jesli wyjscia sa inne niz standardowe to zamieniamy je - przekierowanie wyjscia
if(inputFile != STDIN_FILENO)
{
dup2(inputFile, STDIN_FILENO);
close(inputFile);
}
if(outputFile != STDOUT_FILENO)
{
dup2(outputFile, STDOUT_FILENO);
close(outputFile);
}
if(errorFile != STDERR_FILENO)
{
dup2(errorFile, STDERR_FILENO);
close(errorFile);
} if(strcmp(proc->argv[0], "pwd") == 0)
{
do_pwd();
}
else if(strcmp(proc->argv[0], "cd") == 0)
{
do_cd(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "ls") == 0)
{
do_ls(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "mkdir") == 0)
{
do_mkdir(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "rmdir") == 0)
{
do_rmdir(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "touch") == 0)
{
do_touch(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "rm") == 0)
{
do_rm(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "cp") == 0)
{
do_cp(proc->argv[1], proc->argv[2]);
}
else if(strcmp(proc->argv[0], "echo") == 0)
{
do_echo(proc->argv[1]);
}
else
run(proc->argv[0], proc->argv);
//execvp(proc->argv[0], proc->argv);
// nie powinien wykonac exit'a przy poprawnym wykonaniu
//exit(-1);
}
