int setup_workers(struct ev_loop* loop, struct listener_s* listener) {
char* ip = listener->argv[1];
uint16_t port = (uint16_t)atoi(listener->argv[2]);
int listen_fd;
#ifndef SO_REUSEPORT
listen_fd = start_listen(ip, port);
#endif
pid_t pid;
int i;
struct worker_s* workers = listener->workers;
for (i = 0; i < listener->worker_count; i++) {
#ifdef SO_REUSEPORT
listen_fd = start_listen(ip, port);
#endif
workers[i].listen_fd = listen_fd;
workers[i].worker_id = i;
workers[i].listener = listener;
pid = spawn_worker(&workers[i]);
if (pid < 0) {
return -1;
}
workers[i].pid = pid;
ev_child_init(&workers[i].cwatcher, exit_cb, pid, 0);
ev_child_start(loop, &workers[i].cwatcher);
}
return 0;
}
int
gate_init(struct gate *g , struct skynet_context * ctx, char * parm) {
if (parm == NULL)
return 1;
int max = 0;
int buffer = 0;
int sz = strlen(parm)+1;
char watchdog[sz];
char binding[sz];
int client_tag = 0;
char header;
int n = sscanf(parm, "%c %s %s %d %d %d",&header,watchdog, binding,&client_tag , &max,&buffer);
if (n<4) {
skynet_error(ctx, "Invalid gate parm %s",parm);
return 1;
}
if (max <=0 ) {
skynet_error(ctx, "Need max connection");
return 1;
}
if (header != 'S' && header !='L') {
skynet_error(ctx, "Invalid data header style");
return 1;
}
if (client_tag == 0) {
client_tag = PTYPE_CLIENT;
}
if (watchdog[0] == '!') {
g->watchdog = 0;
} else {
g->watchdog = skynet_queryname(ctx, watchdog);
if (g->watchdog == 0) {
skynet_error(ctx, "Invalid watchdog %s",watchdog);
return 1;
}
}
g->ctx = ctx;
int cap = 16;
while (cap < max) {
cap *= 2;
}
hashid_init(&g->hash, max, cap);
g->conn = malloc(max * sizeof(struct connection));
memset(g->conn, 0, max *sizeof(struct connection));
g->max_connection = max;
int i;
for (i=0;i<max;i++) {
g->conn[i].id = -1;
}
g->client_tag = client_tag;
g->header_size = header=='S' ? 2 : 4;
skynet_callback(ctx,g,_cb);
return start_listen(g,binding);
}
int main (int argc, char * argv[])
{
int i, status, lsockfd, csockfd; /* local/connection socket file descriptor */
struct sockaddr_in raddr; /* remote address object */
socklen_t raddr_len = sizeof (struct sockaddr_in);
pthread_t connThread; /* thread identifier */
User_Settings * o_stngs; /* user suplied settings struct (stores user settings)*/
/* set global variables */
server = "simpleText";
version = 1.0f;
/* allocate user suplied settings struct */
o_stngs = malloc(sizeof(User_Settings));
/* read configuration file */
read_conf_file (o_stngs);
/* parse and set cli options */
parse_cli_opts (argc, (char **) &argv[0], o_stngs);
/* make daemon and start logging */
status = init_daemon (server, o_stngs);
if (status == 0)
return EXIT_SUCCESS; /* parent returns success */
else if (status == 1)
return EXIT_FAILURE; /* parent returns failure */
syslog (LOG_NOTICE, "[PID: %u, SID: %u] > %s started..",
getpid (), getsid (getpid ()), server);
/* Read Hosts File */
host_cnt = read_host_file (NULL, 1);
for (i = 0; i < host_cnt; i++)
read_host_file (&o_vhost[i], 0);
/* start listening for TCP connections */
lsockfd = start_listen (o_stngs->port);
free(o_stngs);
/* loop through accepting and handling connections */
while (1)
{
/* accept connection or skip to next conection if accept fails */
csockfd = accept (lsockfd, (struct sockaddr *) &raddr, &raddr_len);
if (csockfd == -1) /* if connection fails ignore it and continue */
continue;
Connect_Args * o_args = malloc(sizeof(Connect_Args *));
o_args->socket = csockfd;
strcpy (o_args->client_addr, inet_ntoa (raddr.sin_addr));
/* create thread to handle connection */
pthread_create(&connThread, NULL, (void *) &attent_connection, o_args);
/* wait for one second before accepting next connection */
sleep (1);
}
}
int main(int argc, char *argv[]) {
int sock_fd;
bind_serv(&sock_fd);
start_listen(&sock_fd);
run_server(&sock_fd);
return EXIT_SUCCESS;
}
acceptor::acceptor(io::io_service &ep, const ipv4_endpoint &endpoint, std::function<void()> on_accept)
: fd(make_socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK)),
accept_connection(on_accept), ioEntry(ep, fd, EPOLLIN,
[this](uint32_t event)
{
if (event == EPOLLIN) this->accept_connection();
})
{
bind_socket(fd, endpoint.port_net, endpoint.addr_net);
start_listen(fd);
}
int
main(int argc, char *argv[]){
char *dev;
if(argc>1){
/* MAIN BLOCK */
dev = argv[1];
start_listen(dev,"port sip", my_scanner);
}
else{
/* some errors in calling apps */
printf("check for syntax you miss something\n");
}
}
static void run(const char *service, const char *key_file,
const char *cert_file) {
SSL_CTX *ssl_ctx;
app_context app_ctx;
struct event_base *evbase;
ssl_ctx = create_ssl_ctx(key_file, cert_file);
evbase = event_base_new();
initialize_app_context(&app_ctx, ssl_ctx, evbase);
start_listen(evbase, service, &app_ctx);
event_base_loop(evbase, 0);
event_base_free(evbase);
SSL_CTX_free(ssl_ctx);
}
/* -----------------------------------------------------------------------------
----------------------------------------------------------------------------- */
int serial_terminal_window(char *script, int infd, int outfd)
{
int slis, sacc = 0, n;
char c;
char str[32];
//sprintf(str, "/var/run/pppd-%d", getpid());
snprintf(str, sizeof(str), "/var/run/pppd-miniterm");
slis = start_listen(str);
if (slis == -1) {
error("Cannot listen for terminal window application");
status = EXIT_TERMINAL_FAILED;
return -2;
}
if (launch_app(PATH_MINITERM, str) < 0) {
error("Cannot launch terminal window application");
status = EXIT_TERMINAL_FAILED;
close(slis);
return -2;
}
sacc = wait_accept(slis);
close(slis);
if (sacc < 0) {
if (kill_link)
return 0;
error("Cannot communicate with terminal window application.");
status = EXIT_TERMINAL_FAILED;
return -2;
}
send_fd(sacc, infd);
n = readn(sacc, &c, 1);
close(sacc);
if (n != 1) {
if (kill_link)
return 0;
error("Cannot get status from terminal window application (error %m)");
status = EXIT_TERMINAL_FAILED;
return -2;
}
return (unsigned char)c;
}
web_server::web_server(config_t *config, std::vector<client_t *> *clients, pthread_mutex_t *clients_mutex, pools *ppools, statistics_global *ps, fips140 *pfips140, scc *pscc, data_logger *dl, users *pusers)
{
fd = start_listen(config -> webserver_interface.c_str(), config -> webserver_port, config -> listen_queue_size);
add_object(new http_file_root());
add_object(new http_file_404());
add_object(new http_file_stats(clients, clients_mutex, ppools, ps, pfips140, pscc));
add_object(new http_file_version());
add_object(new http_file_file("/stylesheet.css", "text/css", WEB_DIR "/stylesheet.css"));
add_object(new http_file_file("/favicon.ico", "image/x-ico", WEB_DIR "/favicon.ico"));
add_object(new http_file_file("/logo.png", "image/png", WEB_DIR "/logo.png"));
add_object(new http_file_graph_data_logger(dl, config -> graph_font));
add_object(new http_file_logfile(ps));
add_object(new http_file_file("/logo-bw.png", "image/png", WEB_DIR "/logo-bw.png"));
add_object(new http_file_file("/logfiles.png", "image/png", WEB_DIR "/logfiles.png"));
add_object(new http_file_file("/statistics.png", "image/png", WEB_DIR "/statistics.png"));
add_object(new http_file_users(pusers));
add_object(new http_file_file("/users.png", "image/png", WEB_DIR "/users.png"));
}
int BoardE1::KhompPvtE1::makeCall(std::string params)
{
if(callE1()->_call_info_drop == 0 && !callE1()->_call_info_report)
{
command(KHOMP_LOG, CM_DISABLE_CALL_ANSWER_INFO);
}
int ret = KhompPvt::makeCall(params);
if(ret == ksSuccess)
{
start_listen();
}
else
{
K::Logger::Logg(C_ERROR, PVT_FMT(target(), "Fail on make call"));
}
return ret;
}
bool BoardE1::KhompPvtE1::onCallSuccess(K3L_EVENT *e)
{
DBG(FUNC, PVT_FMT(_target, "(E1) c"));
try
{
ScopedPvtLock lock(this);
if (call()->_pre_answer)
{
start_listen();
start_stream();
}
else
{
//TODO: Gerar Ringback caso necessario
call()->_flags.set(Kflags::GEN_PBX_RING);
//idx.pbx_ring = pvt->pvt_timer.add(K::opt::ringback_pbx_delay,
// &K::timers::pbx_ring_gen, pvt, TM_VAL_CALL);
}
}
catch (ScopedLockFailed & err)
{
K::Logger::Logg(C_ERROR,FMT("(E1) r (unable to lock %s!)") % err._msg.c_str() );
return ksFail;
}
KhompPvt::onCallSuccess(e);
DBG(FUNC, PVT_FMT(_target, "(E1) r"));
return ksSuccess;
}
int main(int argc, char *argv[])
{
int lsfd;
int ret, n, i;
struct epoll_event event;
struct epoll_event *events = NULL;
connection_t *conn;
connections_head_t *head = NULL;
if (argc != 2) {
fprintf(stdout, "Usage: %s [port]\n", argv[0]);
exit(EXIT_FAILURE);
}
/* init connections cache */
head = init_connections(MAX_CONNECTIONS);
if (NULL == head) {
ERROR_MSG("init_connections\n");
goto error;
}
/* init SSL data */
ret = init_OpenSSL();
if (ret != 0) {
ERROR_MSG("init_OpenSSL\n");
goto error;
}
head->ctx = init_ssl_ctx(SRV_CERTFILE, SRV_PRIKEY, SRV_CAFILE);
if (NULL == head->ctx) {
ERROR_MSG("init_ssl_ctx error\n");
goto error;
}
/* init epoll's data */
head->epfd = epoll_create(MAX_CONNECTIONS);
if (-1 == head->epfd) {
ERROR_MSG("epoll_create\n");
goto error;
}
events = calloc(MAX_EVENTS, sizeof(struct epoll_event));
if (NULL == events) {
ERROR_MSG("calloc\n");
goto error;
}
/* listen's data */
lsfd = start_listen(argv[1]);
if (lsfd < 0) {
ERROR_MSG("start_listen\n");
goto error;
}
/* add the lsfd to events */
conn = get_connection(head);
if (NULL == conn) {
ERROR_MSG("get_connection\n");
goto error;
}
conn->fd = lsfd;
conn->handler = accept_handler;
event.data.ptr = conn;
event.events = EPOLLIN | EPOLLET;
ret = epoll_ctl(head->epfd, EPOLL_CTL_ADD, lsfd, &event);
if (-1 == ret) {
ERROR_MSG("epoll_ctl\n");
goto error;
}
/* The event loop */
while (1)
{
n = epoll_wait(head->epfd, events, MAX_EVENTS, -1);
for (i = 0; i < n; ++i)
{
conn = events[i].data.ptr;
if ((events[i].events & EPOLLERR)
|| (events[i].events & EPOLLHUP)
|| !(events[i].events & EPOLLIN))
{
/* it will delete the event from events at the same time
* due to invoked close
*/
free_connection(head, conn);
} else {
if (conn->handler) {
conn->handler(head, conn);
}
}
}
}
error:
if (events) free(events);
destroy_connections(head);
return EXIT_SUCCESS;
}
int main() {
start_listen();
process();
return 0;
}
static int client_command(struct mux_client *client, struct usbmuxd_header *hdr)
{
int res;
usbmuxd_log(LL_DEBUG, "Client command in fd %d len %d ver %d msg %d tag %d", client->fd, hdr->length, hdr->version, hdr->message, hdr->tag);
if(client->state != CLIENT_COMMAND) {
usbmuxd_log(LL_ERROR, "Client %d command received in the wrong state", client->fd);
if(send_result(client, hdr->tag, RESULT_BADCOMMAND) < 0)
return -1;
client_close(client);
return -1;
}
if((hdr->version != 0) && (hdr->version != 1)) {
usbmuxd_log(LL_INFO, "Client %d version mismatch: expected 0 or 1, got %d", client->fd, hdr->version);
send_result(client, hdr->tag, RESULT_BADVERSION);
return 0;
}
struct usbmuxd_connect_request *ch;
char *payload;
uint32_t payload_size;
switch(hdr->message) {
case MESSAGE_PLIST:
client->proto_version = 1;
payload = (char*)(hdr) + sizeof(struct usbmuxd_header);
payload_size = hdr->length - sizeof(struct usbmuxd_header);
plist_t dict = NULL;
plist_from_xml(payload, payload_size, &dict);
if (!dict) {
usbmuxd_log(LL_ERROR, "Could not parse plist from payload!");
return -1;
} else {
char *message = NULL;
plist_t node = plist_dict_get_item(dict, "MessageType");
plist_get_string_val(node, &message);
if (!message) {
usbmuxd_log(LL_ERROR, "Could not extract MessageType from plist!");
plist_free(dict);
return -1;
}
if (!strcmp(message, "Listen")) {
free(message);
plist_free(dict);
if (send_result(client, hdr->tag, 0) < 0)
return -1;
usbmuxd_log(LL_DEBUG, "Client %d now LISTENING", client->fd);
return start_listen(client);
} else if (!strcmp(message, "Connect")) {
uint64_t val;
uint16_t portnum = 0;
uint32_t device_id = 0;
free(message);
// get device id
node = plist_dict_get_item(dict, "DeviceID");
if (!node) {
usbmuxd_log(LL_ERROR, "Received connect request without device_id!");
plist_free(dict);
if (send_result(client, hdr->tag, RESULT_BADDEV) < 0)
return -1;
return 0;
}
val = 0;
plist_get_uint_val(node, &val);
device_id = (uint32_t)val;
// get port number
node = plist_dict_get_item(dict, "PortNumber");
if (!node) {
usbmuxd_log(LL_ERROR, "Received connect request without port number!");
plist_free(dict);
if (send_result(client, hdr->tag, RESULT_BADCOMMAND) < 0)
return -1;
return 0;
}
val = 0;
plist_get_uint_val(node, &val);
portnum = (uint16_t)val;
plist_free(dict);
usbmuxd_log(LL_DEBUG, "Client %d connection request to device %d port %d", client->fd, device_id, ntohs(portnum));
res = device_start_connect(device_id, ntohs(portnum), client);
if(res < 0) {
if (send_result(client, hdr->tag, -res) < 0)
return -1;
} else {
client->connect_tag = hdr->tag;
client->connect_device = device_id;
client->state = CLIENT_CONNECTING1;
}
return 0;
} else if (!strcmp(message, "ListDevices")) {
free(message);
plist_free(dict);
if (send_device_list(client, hdr->tag) < 0)
return -1;
return 0;
} else if (!strcmp(message, "ReadBUID")) {
free(message);
plist_free(dict);
if (send_system_buid(client, hdr->tag) < 0)
return -1;
return 0;
} else if (!strcmp(message, "ReadPairRecord")) {
free(message);
char* record_id = plist_dict_get_string_val(dict, "PairRecordID");
plist_free(dict);
res = send_pair_record(client, hdr->tag, record_id);
if (record_id)
free(record_id);
if (res < 0)
return -1;
return 0;
} else if (!strcmp(message, "SavePairRecord")) {
uint32_t rval = RESULT_OK;
free(message);
char* record_id = plist_dict_get_string_val(dict, "PairRecordID");
char* record_data = NULL;
uint64_t record_size = 0;
plist_t rdata = plist_dict_get_item(dict, "PairRecordData");
if (rdata && plist_get_node_type(rdata) == PLIST_DATA) {
plist_get_data_val(rdata, &record_data, &record_size);
}
plist_free(dict);
if (record_id && record_data) {
res = config_set_device_record(record_id, record_data, record_size);
if (res < 0) {
rval = -res;
}
free(record_id);
} else {
rval = EINVAL;
}
if (send_result(client, hdr->tag, rval) < 0)
return -1;
return 0;
} else if (!strcmp(message, "DeletePairRecord")) {
uint32_t rval = RESULT_OK;
free(message);
char* record_id = plist_dict_get_string_val(dict, "PairRecordID");
plist_free(dict);
if (record_id) {
res = config_remove_device_record(record_id);
if (res < 0) {
rval = -res;
}
free(record_id);
} else {
rval = EINVAL;
}
if (send_result(client, hdr->tag, rval) < 0)
return -1;
return 0;
} else {
usbmuxd_log(LL_ERROR, "Unexpected command '%s' received!", message);
free(message);
plist_free(dict);
if (send_result(client, hdr->tag, RESULT_BADCOMMAND) < 0)
return -1;
return 0;
}
}
// should not be reached?!
return -1;
case MESSAGE_LISTEN:
if(send_result(client, hdr->tag, 0) < 0)
return -1;
usbmuxd_log(LL_DEBUG, "Client %d now LISTENING", client->fd);
return start_listen(client);
case MESSAGE_CONNECT:
ch = (void*)hdr;
usbmuxd_log(LL_DEBUG, "Client %d connection request to device %d port %d", client->fd, ch->device_id, ntohs(ch->port));
res = device_start_connect(ch->device_id, ntohs(ch->port), client);
if(res < 0) {
if(send_result(client, hdr->tag, -res) < 0)
return -1;
} else {
client->connect_tag = hdr->tag;
client->connect_device = ch->device_id;
client->state = CLIENT_CONNECTING1;
}
return 0;
default:
usbmuxd_log(LL_ERROR, "Client %d invalid command %d", client->fd, hdr->message);
if(send_result(client, hdr->tag, RESULT_BADCOMMAND) < 0)
return -1;
return 0;
}
return -1;
}
void reverse_shell(int port){
int sock, i, ret, sock_con = 0;
struct sockaddr cli_addr;
struct pollfd pfds[2];
struct timeval timeout;
char ip_connection[INET6_ADDRSTRLEN] = {0};
char buf[1024];
fd_set fd;
socklen_t sockaddr_len = sizeof(struct sockaddr_in);
start_listen(&sock, port);
FD_ZERO(&fd);
FD_SET(sock, &fd);
printf("Listen in background, port: %d, pid: %lld\nWaiting connection ...\n", port, (long long int) getpid());
timeout.tv_sec = LISTEN_TIMEOUT;
timeout.tv_usec = 0;
ret = select(sock+1, &fd, NULL, NULL, &timeout);
if(ret == -1)
die("select() error",1);
else if(!ret){
printf("Connection timeout %d !!!\n",LISTEN_TIMEOUT);
exit(0);
}
if( (sock_con = accept(sock, (struct sockaddr *) &cli_addr, &sockaddr_len)) == -1 )
die("accept() error",1);
if(cli_addr.sa_family == AF_INET){
inet_ntop(AF_INET, &((struct sockaddr_in *)&cli_addr)->sin_addr, ip_connection, INET_ADDRSTRLEN);
} else if(cli_addr.sa_family == AF_INET6){
inet_ntop(AF_INET6, &(((struct sockaddr_in6 *)&cli_addr)->sin6_addr), ip_connection, INET6_ADDRSTRLEN);
} else {
strcpy(ip_connection, "unknow");
}
printf("Connection from: %s\n\n", ip_connection);
pfds[1].fd = 0;
pfds[1].events = POLLIN;
pfds[0].fd = sock_con;
pfds[0].events = POLLIN;
while(1){
poll(pfds, 2, -1);
if(pfds[1].revents & POLLIN){
i = read(0, buf, 1023);
if(!i)
break;
write(sock_con, buf, i);
}
if(pfds[0].revents & POLLIN){
i = read(sock_con, buf, 1023);
if(!i)
break;
write(1, buf, i);
}
}
exit(0);
}
int
main(int argc, char **argv)
{
int opt, port, use_record = 0, use_compact = 0, debugging = 0, listen = 0;
BroConn *bc;
extern char *optarg;
extern int optind;
char hostname[512];
int fd = -1;
bro_init(NULL);
host_str = host_default;
port_str = port_default;
bro_debug_calltrace = 0;
bro_debug_messages = 0;
while ( (opt = getopt(argc, argv, "Cc:p:dh?lr")) != -1)
{
switch (opt)
{
case 'd':
debugging++;
if (debugging == 1)
bro_debug_messages = 1;
if (debugging > 1)
bro_debug_calltrace = 1;
break;
case 'l':
listen = 1;
break;
case 'h':
case '?':
usage();
case 'c':
count = strtol(optarg, NULL, 0);
if (errno == ERANGE || count < 1)
{
printf("Please provide an integer to -c.\n");
exit(-1);
}
break;
case 'p':
port_str = optarg;
break;
case 'r':
use_record = 1;
break;
case 'C':
use_compact = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc > 0)
host_str = argv[0];
/*
if (! (host = gethostbyname(host_str)) ||
! (host->h_addr_list[0]))
{
printf("Could not resolve host %s\n", host_str);
exit(-1);
}
*/
port = strtol(port_str, NULL, 0);
if (errno == ERANGE)
{
printf("Please provide a port number with -p.\n");
exit(-1);
}
snprintf(hostname, 512, "%s:%s", host_str, port_str);
if ( listen )
bc = start_listen(port);
/* Connect to Bro */
else if (! (bc = bro_conn_new_str(hostname, BRO_CFLAG_RECONNECT | BRO_CFLAG_ALWAYS_QUEUE)))
{
printf("Could not get Bro connection handle.\n");
exit(-1);
}
/* Request "pong" events, and have bro_pong called when they
* arrive. The callback mechanism automatically figures out
* the number of arguments and invokes the callback accordingly.
* Use record-based callback if -r option was given, and compact
* argument passing if -C was provided.
*/
if (use_compact)
{
if (use_record)
bro_event_registry_add_compact(bc, "pong", (BroCompactEventFunc)
bro_pong_compact_record, NULL);
else
bro_event_registry_add_compact(bc, "pong", (BroCompactEventFunc)
bro_pong_compact, NULL);
}
else
{
if (use_record)
bro_event_registry_add(bc, "pong", (BroEventFunc) bro_pong_record, NULL);
else
bro_event_registry_add(bc, "pong", (BroEventFunc) bro_pong, NULL);
}
if (! bro_conn_connect(bc))
{
printf("Could not connect to Bro at %s:%s.\n", host_str, port_str);
exit(-1);
}
/* Enter pinging loop */
for ( ; ; )
{
BroEvent *ev;
bro_conn_process_input(bc);
if (count > 0 && seq == count)
break;
/* Create empty "ping" event */
if ( (ev = bro_event_new("ping")))
{
double timestamp = bro_util_current_time();
if (use_record)
{
/* Create a record with the sequence number as first
* element of type counter, and the second element the
* current time:
*/
BroRecord *rec = bro_record_new();
bro_record_add_val(rec, "seq", BRO_TYPE_COUNT, NULL, &seq);
bro_record_add_val(rec, "src_time", BRO_TYPE_TIME, NULL, ×tamp);
bro_event_add_val(ev, BRO_TYPE_RECORD, NULL, rec);
bro_record_free(rec);
}
else
{
/* Add a timestamp to it: */
bro_event_add_val(ev, BRO_TYPE_TIME, NULL, ×tamp);
/* Add the sequence counter: */
bro_event_add_val(ev, BRO_TYPE_COUNT, NULL, &seq);
}
seq++;
/* Ship it -- sends it if possible, queues it otherwise */
bro_event_send(bc, ev);
bro_event_free(ev);
}
#ifdef __MINGW32__
sleep(1000);
#else
sleep(1);
#endif
}
/* Disconnect from Bro and release state. */
bro_conn_delete(bc);
return 0;
}
int main(int argc,char* argv[])
{
if(argc!=5)
{
cout<<"Usage: [ip] [user] [pass] [filename]"<<endl;
return -1;
}
int sock=socket(AF_INET,SOCK_STREAM,0);
if(sock<0)
{
perror("socket");
return -1;
}
sockaddr_in server_addr;
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=inet_addr(argv[1]);
server_addr.sin_port=htons(21);
int ret=connect(sock,(sockaddr*)&server_addr,sizeof(server_addr));
if(ret<0)
{
perror("connect");
return 2;
}
char buf[SIZE];
char output[SIZE];
ssize_t _s=recv(sock,buf,SIZE,0);
if(_s<0)
{
perror("recv");
return _s;
}
buf[_s]='\0';
cout<<buf<<endl;
sprintf(buf,"USER %s\r\n",argv[2]);
if(interact(sock,buf,output)<0)
{
perror("USER");
return -1;
}
cout<<output<<endl;
sprintf(buf,"PASS %s\r\n",argv[3]);
if(interact(sock,buf,output)<0)
{
perror("PASS");
return -1;
}
cout<<output<<endl;
sockaddr_in local_addr;
int listen_sock=start_listen(sock,local_addr);
if(listen_sock<0)
{
perror("start_listen");
return -1;
}
unsigned char* _ip=(unsigned char*)&local_addr.sin_addr.s_addr;
unsigned short _port=ntohs(local_addr.sin_port);
sprintf(buf, "PORT %d,%d,%d,%d,%d,%d\r\n", _ip[0], _ip[1], _ip[2],_ip[3],_port/256,_port%256);
cout<<buf<<endl;
if(interact(sock,buf,output)<0)
{
cout<<"interact"<<endl;
return -1;
}
cout<<output<<endl;
sprintf(buf,"RETR %s\r\n",argv[4]);
if(interact(sock,buf,output)<0)
{
cout<<"interact"<<endl;
return -1;
}
cout<<output<<endl;
sockaddr_in ser_addr;
socklen_t ser_len=sizeof(ser_addr);
int data_sock=accept(listen_sock,(sockaddr*)&ser_addr,&ser_len);
if(data_sock<0)
{
perror("accept");
return -1;
}
close(listen_sock);
ret=recv_data(data_sock,argv[4]);
if (ret < 0) {
cout << "recv data error" << endl;
}
close(sock);
return 0;
}
// main(argc, argv)
// The main loop!
int main(int argc, char *argv[])
{
task_t *tracker_task, *listen_task, *t;
struct in_addr tracker_addr;
int tracker_port;
char *s;
const char *myalias;
struct passwd *pwent;
// Default tracker is read.cs.ucla.edu
osp2p_sscanf("131.179.80.139:11111", "%I:%d",
&tracker_addr, &tracker_port);
if ((pwent = getpwuid(getuid()))) {
myalias = (const char *) malloc(strlen(pwent->pw_name) + 20);
sprintf((char *) myalias, "%s%d", pwent->pw_name,
(int) time(NULL));
} else {
myalias = (const char *) malloc(40);
sprintf((char *) myalias, "osppeer%d", (int) getpid());
}
// Ignore broken-pipe signals: if a connection dies, server should not
signal(SIGPIPE, SIG_IGN);
// Process arguments
argprocess:
if (argc >= 3 && strcmp(argv[1], "-t") == 0
&& (osp2p_sscanf(argv[2], "%I:%d", &tracker_addr, &tracker_port) >= 0
|| osp2p_sscanf(argv[2], "%d", &tracker_port) >= 0
|| osp2p_sscanf(argv[2], "%I", &tracker_addr) >= 0)
&& tracker_port > 0 && tracker_port <= 65535) {
argc -= 2, argv += 2;
goto argprocess;
} else if (argc >= 2 && argv[1][0] == '-' && argv[1][1] == 't'
&& (osp2p_sscanf(argv[1], "-t%I:%d", &tracker_addr, &tracker_port) >= 0
|| osp2p_sscanf(argv[1], "-t%d", &tracker_port) >= 0
|| osp2p_sscanf(argv[1], "-t%I", &tracker_addr) >= 0)
&& tracker_port > 0 && tracker_port <= 65535) {
--argc, ++argv;
goto argprocess;
} else if (argc >= 3 && strcmp(argv[1], "-d") == 0) {
if (chdir(argv[2]) == -1)
die("chdir");
argc -= 2, argv += 2;
goto argprocess;
} else if (argc >= 2 && argv[1][0] == '-' && argv[1][1] == 'd') {
if (chdir(argv[1]+2) == -1)
die("chdir");
--argc, ++argv;
goto argprocess;
} else if (argc >= 3 && strcmp(argv[1], "-b") == 0
&& osp2p_sscanf(argv[2], "%d", &evil_mode) >= 0) {
argc -= 2, argv += 2;
goto argprocess;
} else if (argc >= 2 && argv[1][0] == '-' && argv[1][1] == 'b'
&& osp2p_sscanf(argv[1], "-b%d", &evil_mode) >= 0) {
--argc, ++argv;
goto argprocess;
} else if (argc >= 2 && strcmp(argv[1], "-b") == 0) {
evil_mode = 1;
--argc, ++argv;
goto argprocess;
} else if (argc >= 2 && (strcmp(argv[1], "--help") == 0
|| strcmp(argv[1], "-h") == 0)) {
printf("Usage: osppeer [-tADDR:PORT | -tPORT] [-dDIR] [-b]\n"
"Options: -tADDR:PORT Set tracker address and/or port.\n"
" -dDIR Upload and download files from directory DIR.\n"
" -b[MODE] Evil mode!!!!!!!!\n");
exit(0);
}
// Connect to the tracker and register our files.
tracker_task = start_tracker(tracker_addr, tracker_port);
listen_task = start_listen();
register_files(tracker_task, myalias);
// First, download files named on command line.
pid_t pid;
for (; argc > 1; argc--, argv++)
if ((t = start_download(tracker_task, argv[1]))){
pid = fork();
if(pid == 0){
task_download(t, tracker_task);
_exit(0);
}
else if(pid > 0){}
else if(pid == -1)
error("Fork failed for download\n");
}
int n_tasks = 0;
// Then accept connections from other peers and upload files to them!
while ((t = task_listen(listen_task))){
message("Beginning of while, n_tasks = %d\n", n_tasks);
if(n_tasks >= MAX_NUM_TASKS){
if(waitpid(-1, 0, 0) > 0){
message("Waiting for other proc, n_tasks = %d\n", n_tasks);
n_tasks--;
}
}
else if(n_tasks < MAX_NUM_TASKS){
pid = fork();
if(pid == 0){
//message("New Task STARTED for upload, n_tasks = %d\n", n_tasks);
task_upload(t);
//message("New Task ENDED for upload, n_tasks = %d\n", n_tasks);
_exit(0);
}
else if(pid > 0){
n_tasks++;
}
else if(pid == -1)
error("Fork failed for upload\n");
}
}
return 0;
}
