bool client_d::try_keyboard() {
BOOST_ASSERT( m_session );
BOOST_ASSERT( uname.size() );
int ec = libssh2_userauth_keyboard_interactive(m_session, uname.c_str(), &client_d::kbd_callback);
while( ec == LIBSSH2_ERROR_EAGAIN ) {
wait_on_socket();
ec = libssh2_userauth_keyboard_interactive(m_session, uname.c_str(), &client_d::kbd_callback);
}
return !ec;
}
void client_d::connect() {
try {
if( libssh2_init(0) < 0 ) {
MACE_SSH_THROW( "Unable to init libssh2" );
}
slog( "resolve %1%:%2%", hostname, port );
std::vector<mace::cmt::asio::tcp::endpoint> eps
= mace::cmt::asio::tcp::resolve( hostname, boost::lexical_cast<std::string>(port));
slog( "resolved %1% options", eps.size() );
if( eps.size() == 0 ) {
MACE_SSH_THROW( "Hostname '%1%' didn't resolve to any endpoints", %hostname );
}
m_sock.reset( new boost::asio::ip::tcp::socket( mace::cmt::asio::default_io_service() ) );
for( uint32_t i = 0; i < eps.size(); ++i ) {
try {
mace::cmt::asio::tcp::connect( *m_sock, eps[i] );
endpt = eps[i];
break;
} catch ( ... ) {}
}
slog( "Creating session" );
m_session = libssh2_session_init();
*libssh2_session_abstract(m_session) = this;
BOOST_ASSERT( m_session );
// use non-blocking calls so that we know when to call wait_on_socket
libssh2_session_set_blocking( m_session, 0 );
// perform the session handshake, and keep trying while EAGAIN
int ec = libssh2_session_handshake( m_session, m_sock->native() );
while( ec == LIBSSH2_ERROR_EAGAIN ) {
wait_on_socket();
ec = libssh2_session_handshake( m_session, m_sock->native() );
}
// if there was an error, throw it.
if( ec < 0 ) {
char* msg;
libssh2_session_last_error( m_session, &msg, 0, 0 );
MACE_SSH_THROW( "Handshake error: %1% - %2%", %ec %msg );
}
int main()
{
uint32 bufferout[WIDTH * HEIGHT];
char bufferin[LOOKUP_TABLE_SIZE];
server_type = SERVER_TYPE_SERIAL;
int fd;
turn_on_camera();
while(1)
{
printf("i am trying to wait for a connection\n");
fd = wait_on_socket();
printf("i received a connection\n");
if (fd < 0)
{
printf("Can't connect: %s\n", strerror(errno));
exit(1);
}
// get the command
readn(fd, bufferin, 1);
if (bufferin[0] == COMMAND_PICTURE)
{
lua_take_save_images(bufferout);
lua_take_save_images(bufferout);
lua_take_save_images(bufferout);
writen(fd, (char*)bufferout, WIDTH * HEIGHT*2); // had to half to make faster
}
else if (bufferin[0] == COMMAND_LOOKUP)
{
readn(fd, bufferin, LOOKUP_TABLE_SIZE);
int fd2 = open("/home/darwin/dev/merc/darwin/UPENN2013/Player/Data/lut_demoOP.raw", O_WRONLY | O_CREAT | O_TRUNC, 0666);
writen(fd2, bufferin, LOOKUP_TABLE_SIZE);
close(fd2);
printf("Lookup Table Written\n");
// All LOOKUP_TABLE_SIZE bytes are now in the buffer. process them here -- Sean
// ...
}
else
{
printf("Unknown byte received: %d\n", (int)bufferin[0]);
}
close(fd);
}
}
/* Create a socket connected to a name. */
int
__nscd_open_socket (const char *key, size_t keylen, request_type type,
void *response, size_t responselen)
{
int saved_errno = errno;
int sock = open_socket ();
if (sock >= 0)
{
request_header req;
req.version = NSCD_VERSION;
req.type = type;
req.key_len = keylen;
struct iovec vec[2];
vec[0].iov_base = &req;
vec[0].iov_len = sizeof (request_header);
vec[1].iov_base = (void *) key;
vec[1].iov_len = keylen;
ssize_t nbytes = TEMP_FAILURE_RETRY (__writev (sock, vec, 2));
if (nbytes == (ssize_t) (sizeof (request_header) + keylen)
/* Wait for data. */
&& wait_on_socket (sock) > 0)
{
nbytes = TEMP_FAILURE_RETRY (__read (sock, response, responselen));
if (nbytes == (ssize_t) responselen)
return sock;
}
close_not_cancel_no_status (sock);
}
__set_errno (saved_errno);
return -1;
}
/* Try to get a file descriptor for the shared meory segment
containing the database. */
static struct mapped_database *
get_mapping (request_type type, const char *key,
struct mapped_database **mappedp)
{
struct mapped_database *result = NO_MAPPING;
#ifdef SCM_RIGHTS
const size_t keylen = strlen (key) + 1;
char resdata[keylen];
int saved_errno = errno;
int mapfd = -1;
/* Send the request. */
struct iovec iov[2];
request_header req;
int sock = open_socket ();
if (sock < 0)
goto out;
req.version = NSCD_VERSION;
req.type = type;
req.key_len = keylen;
iov[0].iov_base = &req;
iov[0].iov_len = sizeof (req);
iov[1].iov_base = (void *) key;
iov[1].iov_len = keylen;
if (__builtin_expect (TEMP_FAILURE_RETRY (__writev (sock, iov, 2))
!= iov[0].iov_len + iov[1].iov_len, 0))
/* We cannot even write the request. */
goto out_close2;
/* Room for the data sent along with the file descriptor. We expect
the key name back. */
iov[0].iov_base = resdata;
iov[0].iov_len = keylen;
union
{
struct cmsghdr hdr;
char bytes[CMSG_SPACE (sizeof (int))];
} buf;
struct msghdr msg = { .msg_iov = iov, .msg_iovlen = 1,
.msg_control = buf.bytes,
.msg_controllen = sizeof (buf) };
struct cmsghdr *cmsg = CMSG_FIRSTHDR (&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN (sizeof (int));
/* This access is well-aligned since BUF is correctly aligned for an
int and CMSG_DATA preserves this alignment. */
*(int *) CMSG_DATA (cmsg) = -1;
msg.msg_controllen = cmsg->cmsg_len;
if (wait_on_socket (sock) <= 0)
goto out_close2;
# ifndef MSG_NOSIGNAL
# define MSG_NOSIGNAL 0
# endif
if (__builtin_expect (TEMP_FAILURE_RETRY (__recvmsg (sock, &msg,
MSG_NOSIGNAL))
!= keylen, 0))
goto out_close2;
mapfd = *(int *) CMSG_DATA (cmsg);
if (__builtin_expect (CMSG_FIRSTHDR (&msg)->cmsg_len
!= CMSG_LEN (sizeof (int)), 0))
goto out_close;
struct stat64 st;
if (__builtin_expect (strcmp (resdata, key) != 0, 0)
|| __builtin_expect (fstat64 (mapfd, &st) != 0, 0)
|| __builtin_expect (st.st_size < sizeof (struct database_pers_head), 0))
goto out_close;
struct database_pers_head head;
if (__builtin_expect (TEMP_FAILURE_RETRY (__pread (mapfd, &head,
sizeof (head), 0))
!= sizeof (head), 0))
goto out_close;
if (__builtin_expect (head.version != DB_VERSION, 0)
|| __builtin_expect (head.header_size != sizeof (head), 0)
/* This really should not happen but who knows, maybe the update
thread got stuck. */
|| __builtin_expect (! head.nscd_certainly_running
&& head.timestamp + MAPPING_TIMEOUT < time (NULL),
0))
goto out_close;
size_t size = (sizeof (head) + roundup (head.module * sizeof (ref_t), ALIGN)
+ head.data_size);
if (__builtin_expect (st.st_size < size, 0))
goto out_close;
/* The file is large enough, map it now. */
void *mapping = __mmap (NULL, size, PROT_READ, MAP_SHARED, mapfd, 0);
if (__builtin_expect (mapping != MAP_FAILED, 1))
{
/* Allocate a record for the mapping. */
struct mapped_database *newp = malloc (sizeof (*newp));
if (newp == NULL)
{
/* Ugh, after all we went through the memory allocation failed. */
__munmap (mapping, size);
goto out_close;
}
newp->head = mapping;
newp->data = ((char *) mapping + head.header_size
+ roundup (head.module * sizeof (ref_t), ALIGN));
newp->mapsize = size;
/* Set counter to 1 to show it is usable. */
newp->counter = 1;
result = newp;
}
out_close:
__close (mapfd);
out_close2:
__close (sock);
out:
__set_errno (saved_errno);
#endif /* SCM_RIGHTS */
struct mapped_database *oldval = *mappedp;
*mappedp = result;
if (oldval != NULL && atomic_decrement_val (&oldval->counter) == 0)
__nscd_unmap (oldval);
return result;
}
struct mapped_database *
__nscd_get_map_ref (request_type type, const char *name,
struct locked_map_ptr *mapptr, int *gc_cyclep)
{
struct mapped_database *cur = mapptr->mapped;
if (cur == NO_MAPPING)
return cur;
int cnt = 0;
while (atomic_compare_and_exchange_val_acq (&mapptr->lock, 1, 0) != 0)
{
// XXX Best number of rounds?
if (++cnt > 5)
return NO_MAPPING;
atomic_delay ();
}
cur = mapptr->mapped;
if (__builtin_expect (cur != NO_MAPPING, 1))
{
/* If not mapped or timestamp not updated, request new map. */
if (cur == NULL
|| (cur->head->nscd_certainly_running == 0
&& cur->head->timestamp + MAPPING_TIMEOUT < time (NULL)))
cur = get_mapping (type, name, &mapptr->mapped);
if (__builtin_expect (cur != NO_MAPPING, 1))
{
if (__builtin_expect (((*gc_cyclep = cur->head->gc_cycle) & 1) != 0,
0))
cur = NO_MAPPING;
else
atomic_increment (&cur->counter);
}
}
mapptr->lock = 0;
return cur;
}
const struct datahead *
__nscd_cache_search (request_type type, const char *key, size_t keylen,
const struct mapped_database *mapped)
{
unsigned long int hash = __nis_hash (key, keylen) % mapped->head->module;
ref_t work = mapped->head->array[hash];
while (work != ENDREF)
{
struct hashentry *here = (struct hashentry *) (mapped->data + work);
if (type == here->type && keylen == here->len
&& memcmp (key, mapped->data + here->key, keylen) == 0)
{
/* We found the entry. Increment the appropriate counter. */
const struct datahead *dh
= (struct datahead *) (mapped->data + here->packet);
/* See whether we must ignore the entry or whether something
is wrong because garbage collection is in progress. */
if (dh->usable && ((char *) dh + dh->allocsize
<= (char *) mapped->head + mapped->mapsize))
return dh;
}
work = here->next;
}
return NULL;
}
int main(void)
{
CURL *curl;
CURLcode res;
/* Minimalistic http request */
const char *request = "GET / HTTP/1.0\r\nHost: example.com\r\n\r\n";
curl_socket_t sockfd; /* socket */
long sockextr;
size_t iolen;
curl_off_t nread;
curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com");
/* Do not do the transfer - only connect to host */
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 1L);
res = curl_easy_perform(curl);
if(CURLE_OK != res)
{
printf("Error: %s\n", strerror(res));
return 1;
}
/* Extract the socket from the curl handle - we'll need it for waiting.
* Note that this API takes a pointer to a 'long' while we use
* curl_socket_t for sockets otherwise.
*/
res = curl_easy_getinfo(curl, CURLINFO_LASTSOCKET, &sockextr);
if(CURLE_OK != res)
{
printf("Error: %s\n", curl_easy_strerror(res));
return 1;
}
sockfd = sockextr;
/* wait for the socket to become ready for sending */
if(!wait_on_socket(sockfd, 0, 60000L))
{
printf("Error: timeout.\n");
return 1;
}
puts("Sending request.");
/* Send the request. Real applications should check the iolen
* to see if all the request has been sent */
res = curl_easy_send(curl, request, strlen(request), &iolen);
if(CURLE_OK != res)
{
printf("Error: %s\n", curl_easy_strerror(res));
return 1;
}
puts("Reading response.");
/* read the response */
for(;;)
{
char buf[1024];
wait_on_socket(sockfd, 1, 60000L);
res = curl_easy_recv(curl, buf, 1024, &iolen);
if(CURLE_OK != res)
break;
nread = (curl_off_t)iolen;
printf("Received %" CURL_FORMAT_CURL_OFF_T " bytes.\n", nread);
}
/* always cleanup */
curl_easy_cleanup(curl);
}
return 0;
}
void spider(void *pack,char *line,char * pathtable)
{
struct MemoryStruct chunk;
FILE *fp=NULL;
bool match_string=false,save_response=false,test_tamper=false;
long status=0,length=0;
int old=0,res=0,counter=0,counter_cookie=0,counter_agent=0,POST=0,timeout=0,debug_host=3;
char *make=NULL,*make_cookie=NULL,*make_agent=NULL,*tamper=NULL,*responsetemplate=NULL,*tmp_response=NULL,*tmp_make=NULL,*tmp_make_cookie=NULL,*tmp_make_agent=NULL,*tmp_line=NULL,*tmp_line2=NULL;
char **pack_ptr=(char **)pack,**arg = pack_ptr;
char randname[16],line2[1024],log[2048],tabledata[4086],pathsource[1024];
if(arg[12]!=NULL)
save_response=true;
if(arg[8]!=NULL)
timeout=atoi(arg[8]);
// payload tamper
if(arg[20]!=NULL)
{
tamper=arg[20];
if(strstr(tamper,"encode64"))
{
line=encode64(line,strlen(line)-1);
test_tamper=true;
}
if(strstr(tamper,"randcase"))
{
line=rand_case(line);
test_tamper=true;
}
if(strstr(tamper,"urlencode"))
{
line=urlencode(line);
test_tamper=true;
}
if(strstr(tamper,"double_urlencode"))
{
line=double_urlencode(line);
test_tamper=true;
}
if(strstr(tamper,"spaces2comment"))
{
line=spaces2comment(line);
test_tamper=true;
}
if(strstr(tamper,"unmagicquote"))
{
line=unmagicquote(line);
test_tamper=true;
}
if(strstr(tamper,"apostrophe2nullencode"))
{
line=apostrophe2nullencode(line);
test_tamper=true;
}
if(strstr(tamper,"rand_comment"))
{
line=rand_comment(line);
test_tamper=true;
}
if(strstr(tamper,"rand_space"))
{
line=rand_space(line);
test_tamper=true;
}
if(test_tamper==false)
{
DEBUG("error at tamper argument\n");
exit(0);
}
}
memset(pathsource,0,sizeof(char)*1023);
if(save_response==false)
{
strcat(pathsource,"0");
}
// brute POST/GET/COOKIES/UserAgent
if(arg[21]==NULL)
{
POST=(arg[4]==NULL)?0:1;
counter=char_type_counter(POST?arg[4]:arg[0],'^');
counter_cookie=char_type_counter(arg[13]!=NULL?arg[13]:"",'^');
counter_agent=char_type_counter(arg[19]!=NULL?arg[19]:"",'^');
old=counter;
} else {
char *file_request=readLine(arg[21]);
counter=char_type_counter(file_request,'^');
old=counter;
xfree((void**)&file_request);
}
chomp(line);
// goto to fix signal stop if user do ctrl+c
try_again:
while ( old > 0 || counter_cookie > 0 || counter_agent > 0 )
{
CURL *curl;
// curl_global_init(CURL_GLOBAL_ALL);
chunk.memory=NULL;
chunk.size = 0;
curl_socket_t sockfd; /* socket */
long sockextr;
size_t iolen;
curl = curl_easy_init();
// DEBUG("counts ^ : %d \n",old);
if(arg[21]==NULL)
{
make=payload_injector( (POST?arg[4]:arg[0]),line,old);
if(arg[13]!=NULL)
make_cookie=payload_injector( arg[13],line,counter_cookie);
if(arg[19]!=NULL)
make_agent=payload_injector( arg[19],line,counter_agent);
curl_easy_setopt(curl, CURLOPT_URL, POST?arg[0]:make);
} else {
// if is custom request
char *request_file=readLine(arg[21]);
make=payload_injector( request_file,line,old);
curl_easy_setopt(curl, CURLOPT_URL, arg[0]);
xfree((void**)&request_file);
}
if ( POST )
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, make);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
// load user agent
if ( arg[6]!=NULL )
{
curl_easy_setopt(curl, CURLOPT_USERAGENT, arg[6]);
} else {
curl_easy_setopt(curl, CURLOPT_USERAGENT, "Mozilla/5.0 (0d1n v0.1) ");
}
// json headers to use JSON
if(arg[14]!=NULL)
{
struct curl_slist *headers = NULL;
curl_slist_append(headers, arg[14]);
if(arg[16]!=NULL)
{
curl_slist_append(headers, "Accept: application/json");
curl_slist_append(headers, "Content-Type: application/json");
}
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_slist_free_all(headers);
} else {
if(arg[16] != NULL)
{
struct curl_slist *headers = NULL;
curl_slist_append(headers, "Accept: application/json");
curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_slist_free_all(headers);
}
}
//use custom method PUT,DELETE...
if(arg[15]!=NULL)
{
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, arg[15]);
}
curl_easy_setopt(curl, CURLOPT_ENCODING,"gzip,deflate");
// load cookie jar
if ( arg[3] != NULL )
{
curl_easy_setopt(curl,CURLOPT_COOKIEFILE,arg[3]);
curl_easy_setopt(curl,CURLOPT_COOKIEJAR,arg[3]);
} else {
curl_easy_setopt(curl,CURLOPT_COOKIEJAR,"odin_cookiejar.txt");
}
// LOAD cookie fuzz
if(arg[13]!=NULL)
{
curl_easy_setopt(curl,CURLOPT_COOKIE,make_cookie);
}
// LOAD UserAgent FUZZ
if(arg[19]!=NULL)
{
curl_easy_setopt(curl,CURLOPT_USERAGENT,make_agent);
}
curl_easy_setopt(curl,CURLOPT_FOLLOWLOCATION,1);
// Load cacert
if ( arg[7] != NULL )
{
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2);
curl_easy_setopt(curl, CURLOPT_CAINFO, arg[7]);
} else {
curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,0L);
curl_easy_setopt(curl,CURLOPT_SSL_VERIFYHOST,0L);
}
if(timeout)
curl_easy_setopt(curl,CURLOPT_TIMEOUT,timeout);
// load single proxy
if(arg[17] != NULL)
{
curl_easy_setopt(curl, CURLOPT_PROXY, arg[17]);
// curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, 1);
}
// load random proxy in list
if(arg[18] != NULL)
{
char *randproxy=Random_linefile(arg[18]);
// printf("PROXY LOAD: %s\n",randproxy);
curl_easy_setopt(curl, CURLOPT_PROXY, randproxy);
// curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, 1);
}
if ( arg[9] != NULL )
curl_easy_setopt(curl,CURLOPT_SSLVERSION,(long)atoi(arg[9]));
curl_easy_setopt(curl,CURLOPT_VERBOSE,0);
curl_easy_setopt(curl,CURLOPT_HEADER,1);
if(arg[21]!=NULL)
{
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 1L);
}
res=curl_easy_perform(curl);
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE,&status);
// custom http request
if(arg[21]!=NULL)
{
curl_easy_getinfo(curl, CURLINFO_LASTSOCKET, &sockextr);
sockfd = sockextr;
if(!wait_on_socket(sockfd, 0, 60000L))
{
DEBUG("error in socket at custom http request");
}
res=curl_easy_send(curl, make, strlen(make), &iolen);
// recv data
while(1)
{
wait_on_socket(sockfd, 1, 60000L);
chunk.memory=xmalloc(sizeof(char)*3024);
res = curl_easy_recv(curl, chunk.memory, 3023, &iolen);
chunk.size=strlen(chunk.memory);
if(strlen(chunk.memory) > 8)
break;
if(CURLE_OK != res)
break;
}
status=(long)parse_http_status(chunk.memory);
//status=404;
}
// length of response
if(chunk.size<=0)
length=0.0;
else
length=chunk.size;
if(status==0)
{
debug_host--;
DEBUG("Problem in Host: \n %s",chunk.memory);
if(debug_host<0)
exit(0);
goto try_again;
}
// arg[10] list to find with regex , arg[2] list without regex
if( (arg[2]) || (arg[10]) )
{
if(save_response==true)
{
memset(pathsource,0,sizeof(char)*1023);
}
fp = fopen((arg[2]!=NULL)?arg[2]:arg[10], "r");
if ( !fp )
{
DEBUG("error to open response list");
exit(1);
}
while ( fgets(line2,1023,fp) != NULL)
{
chomp(line2);
// find a string in response
if(status != 0)
{
if ( arg[2] != NULL )
match_string=strstr(chunk.memory,line2)?true:false;
if ( arg[10] != NULL )
match_string=strstr_regex(chunk.memory,line2)?true:false;
}
if(chunk.memory && (match_string == true) )
{
if(make_cookie!=NULL)
{
fprintf(stdout,"%s [ %s %ld %s ] Payload: %s %s %s Grep: %s %s %s Params: %s \nCookie: %s %s\n",YELLOW,CYAN,status,YELLOW,GREEN,line,YELLOW,CYAN,line2,YELLOW,make,make_cookie,LAST);
}
if(make_agent!=NULL)
{
fprintf(stdout,"%s [ %s %ld %s ] Payload: %s %s %s Grep: %s %s %s Params: %s \nCookie: %s %s\n",YELLOW,CYAN,status,YELLOW,GREEN,line,YELLOW,CYAN,line2,YELLOW,make,make_agent,LAST);
} else {
fprintf(stdout,"%s [ %s %ld %s ] Payload: %s %s %s Grep: %s %s %s Params: %s %s\n",YELLOW,CYAN,status,YELLOW,GREEN,line,YELLOW,CYAN,line2,YELLOW,make,LAST);
}
if(save_response==true)
{
// create responses path
memset(pathsource,0,sizeof(char)*1023);
strncat(pathsource,"response_sources/",18);
strncat(pathsource,arg[5], 15);
mkdir(pathsource,S_IRWXU|S_IRWXG|S_IRWXO);
snprintf(pathsource,986,"response_sources/%s/%s.html",arg[5],rand_str(randname, sizeof randname));
}
// write log file
snprintf(log,2047,"[ %ld ] Payload: %s Grep: %s Params: %s cookie: %s UserAgent: %s \n Path Response Source: %s\n",status,line,line2,make,(make_cookie!=NULL)?make_cookie:" ",(make_agent!=NULL)?make_agent:" ",pathsource);
WriteFile(arg[5],log);
memset(log,0,2047);
if(save_response==true)
{
// write highlights response
responsetemplate=NULL;
responsetemplate=readLine(TEMPLATE);
WriteFile(pathsource,responsetemplate);
memset(responsetemplate,0,strlen(responsetemplate)-1);
tmp_response=NULL;
tmp_response=html_entities(chunk.memory);
WriteFile(pathsource,tmp_response);
memset(tmp_response,0,strlen(tmp_response)-1);
WriteFile(pathsource,"</pre></html>");
}
// create datatables
tmp_make=html_entities(make);
tmp_line2=html_entities(line2);
tmp_line=html_entities(line);
if(make_cookie!=NULL)
{
tmp_make_cookie=html_entities(make_cookie);
snprintf(tabledata,4085,"[\"<a class=\\\"fancybox fancybox.iframe\\\" href=\\\"../%s\\\">%ld </a>\",\"%ld\",\"%s cookie: %s\",\"%s\",\"%s\"],\n",pathsource,status,length,tmp_make,tmp_make_cookie,tmp_line2,tmp_line);
memset(tmp_make_cookie,0,strlen(tmp_make_cookie)-1);
}
if(make_agent!=NULL)
{
tmp_make_agent=html_entities(make_agent);
snprintf(tabledata,4085,"[\"<a class=\\\"fancybox fancybox.iframe\\\" href=\\\"../%s\\\">%ld </a>\",\"%ld\",\"%s UserAgent: %s\",\"%s\",\"%s\"],\n",pathsource,status,length,tmp_make,tmp_make_agent,tmp_line2,tmp_line);
memset(tmp_make_agent,0,strlen(tmp_make_agent)-1);
} else {
snprintf(tabledata,4085,"[\"<a class=\\\"fancybox fancybox.iframe\\\" href=\\\"../%s\\\">%ld </a>\",\"%ld\",\"%s\",\"%s\",\"%s\"],\n",pathsource,status,length,tmp_make,tmp_line2,tmp_line);
}
WriteFile(pathtable,tabledata);
// memset(tmp_make,0,strlen(tmp_make)-1);
// memset(tmp_make_cookie,0,strlen(tmp_make_cookie)-1);
// memset(tmp_make_agent,0,strlen(tmp_make_agent)-1);
memset(tmp_line,0,strlen(tmp_line)-1);
memset(tmp_line2,0,strlen(tmp_line2)-1);
memset(tabledata,0,4085);
memset(pathsource,0,strlen(pathsource)-1);
}
}
if( fclose(fp) == EOF )
{
DEBUG("Error in close()");
exit(1);
}
fp=NULL;
} else {
if(counter_cookie)
{
fprintf(stdout,"%s [ %s %ld %s ] Payload: %s %s %s Params: %s %s\n Cookie: %s %s\n",YELLOW,CYAN,status,YELLOW,GREEN,line,YELLOW,CYAN,make,make_cookie,LAST);
}
if(counter_agent)
{
fprintf(stdout,"%s [ %s %ld %s ] Payload: %s %s %s Params: %s %s\n UserAgent: %s %s\n",YELLOW,CYAN,status,YELLOW,GREEN,line,YELLOW,CYAN,make,make_agent,LAST);
} else {
fprintf(stdout,"%s [ %s %ld %s ] Payload: %s %s %s Params: %s %s %s\n",YELLOW,CYAN,status,YELLOW,GREEN,line,YELLOW,CYAN,make,LAST);
}
if(save_response==true)
{
// memset(pathsource,0,sizeof(char)*1023);
strncat(pathsource,"response_sources/",18);
strncat(pathsource,arg[5], 15);
mkdir(pathsource,S_IRWXU|S_IRWXG|S_IRWXO);
snprintf(pathsource,986,"response_sources/%s/%s.html",arg[5],rand_str(randname, sizeof randname));
}
//write logs
snprintf(log,2047,"[%ld Payload: %s Params: %s Cookie: %s UserAgent: %s \n Path Response Source: %s\n",status,line,make,(make_cookie!=NULL)?make_cookie:" ",(make_agent!=NULL)?make_agent:" ",pathsource);
WriteFile(arg[5],log);
memset(log,0,2047);
if(save_response==true)
{
// write response source with highlights
responsetemplate=readLine(TEMPLATE);
WriteFile(pathsource,responsetemplate);
//memset(responsetemplate,0,strlen(responsetemplate)-1);
tmp_response=html_entities(chunk.memory);
WriteFile(pathsource,tmp_response);
//memset(tmp_response,0,strlen(tmp_response)-1);
WriteFile(pathsource,"</pre></html>");
}
// create datatables
tmp_make=html_entities(make);
tmp_line=html_entities(line);
if(counter_cookie)
{
tmp_make_cookie=html_entities(make_cookie);
snprintf(tabledata,4085,"[\"<a class=\\\"fancybox fancybox.iframe\\\" href=\\\"../%s\\\">%ld </a>\",\"%ld\",\"%s cookie: %s\",\"\",\"%s\"],\n",pathsource,status,length,tmp_make,tmp_make_cookie,tmp_line);
// memset(tmp_make_cookie,0,strlen(tmp_make_cookie)-1);
}
if(counter_agent)
{
tmp_make_agent=html_entities(make_agent);
snprintf(tabledata,4085,"[\"<a class=\\\"fancybox fancybox.iframe\\\" href=\\\"../%s\\\">%ld </a>\",\"%ld\",\"%s UserAgent: %s\",\"\",\"%s\"],\n",pathsource,status,length,tmp_make,tmp_make_agent,tmp_line);
} else {
snprintf(tabledata,4047,"[\"<a class=\\\"fancybox fancybox.iframe\\\" href=\\\"../%s\\\">%ld </a>\",\"%ld\",\"%s\",\"\",\"%s\"],\n",pathsource,status,length,tmp_make,tmp_line);
}
WriteFile(pathtable,tabledata);
memset(tmp_make,0,strlen(tmp_make)-1);
memset(tmp_line,0,strlen(tmp_line)-1);
memset(tabledata,0,4085);
memset(pathsource,0,strlen(pathsource)-1);
//DEBUG("part B");
}
//DEBUG("END PARTS");
// memset(make,0,strlen(make)-1);
// memset(make_cookie,0,strlen(make_cookie)-1);
// memset(make_agent,0,strlen(make_agent)-1);
// memset(pathsource,0,strlen(pathsource)-1);
xfree((void **)&chunk.memory);
// curl_easy_cleanup(curl);
// curl_global_cleanup();
if(old>0)
old--;
if(counter_cookie > 0)
counter_cookie--;
if(counter_agent > 0)
counter_agent--;
debug_host=3;
}
xfree((void **)&make_agent);
xfree((void **)&make_cookie);
xfree((void **)&make);
xfree((void **)&tmp_make);
xfree((void **)&tmp_make_cookie);
xfree((void **)&tmp_make_agent);
xfree((void **)&tmp_line);
xfree((void **)&tmp_line2);
xfree((void **)&responsetemplate);
xfree((void **)&tmp_response);
if(arg[20] != NULL)
xfree((void **)&line);
// DEBUG("GOOO3");
}
int main(int argc, char** argv) {
wiimote** wiimotes;
int found, connected;
// init
printf("[INFO] Looking for wiimotes (5 seconds)...\n");
wiimotes = wiiuse_init(1);
// find wii (wait for 5 seconds)
found = wiiuse_find(wiimotes, 1, 5);
if (!found) {
printf ("[INFO] No wiimotes found.\n");
return 0;
}
// connect
connected = wiiuse_connect(wiimotes, 1);
if (connected)
printf("[INFO] Connected to %i wiimotes (of %i found).\n", connected, found);
else {
printf("[ERROR] Failed to connect to any wiimote.\n");
return 0;
}
// rumble and set leds
wiiuse_set_leds(wiimotes[0], WIIMOTE_LED_1);
wiiuse_rumble(wiimotes[0], 1);
usleep(200000);
wiiuse_rumble(wiimotes[0], 0);
//set up socket to Java code
server_type = SERVER_TYPE_SERIAL;
int fd = wait_on_socket();
char write_buffer[128];
int button=0;
currently_training = 0;
// continuously poll wiimote and handle events
while (1) {
if (wiiuse_poll(wiimotes, 1)) {
switch (wiimotes[0]->event) {
case WIIUSE_EVENT:
button = handle_event(wiimotes[0]);
break;
case WIIUSE_DISCONNECT:
case WIIUSE_UNEXPECTED_DISCONNECT:
goto exit;
break;
default:
break;
}
}
usleep(50);
// tell Java code info about the wiimote
sprintf (write_buffer, "%d:%d\n", currently_training, button);
writen(fd, write_buffer, strlen(write_buffer));
}
exit:
wiiuse_cleanup(wiimotes, 1);
close(fd);
return 0;
}
bool client_d::try_pub_key() {
BOOST_ASSERT( m_session );
BOOST_ASSERT( uname.size() > 0 );
int ec = libssh2_userauth_publickey_fromfile(m_session,
uname.c_str(),
pubkey.c_str(),
privkey.c_str(),
passphrase.c_str() );
while( ec == LIBSSH2_ERROR_EAGAIN ) {
wait_on_socket();
ec = libssh2_userauth_publickey_fromfile(m_session,
uname.c_str(),
pubkey.c_str(),
privkey.c_str(),
passphrase.c_str() );
}
return !ec;
}
