// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
void entering_info( DWORD SesId, DWORD SesTyp, HANDLE token, LPVOID param ){ //определение пользователя
char *wuser = NULL;
char *bufa = NULL;
char *whost = NULL;
DWORD usersize = 0;
DWORD hostsize = 0;
DWORD size = 0;
// --
if((!WTSQuerySessionInformation( WTS_CURRENT_SERVER_HANDLE, SesId, WTSUserName, &wuser, &usersize ))
||(!WTSQuerySessionInformation( WTS_CURRENT_SERVER_HANDLE, SesId, WTSClientAddress, &bufa, &size ))){
prn_err( "WTSQuerySessionInformation failed.", GetLastError() );
return;
}else if( bufa ){
WTS_CLIENT_ADDRESS *pAddr = (WTS_CLIENT_ADDRESS *) bufa;
if(!WTSQuerySessionInformation( WTS_CURRENT_SERVER_HANDLE, SesId, WTSClientName, &whost, &hostsize )){
prn_err( "WTSQuerySessionInformation failed.", GetLastError() );
}else{
char bs[10];
ZeroMemory(&bs, 12 );
char ba[25];
ZeroMemory(&ba, 26 );
sprintf( ba, "%u.%u.%u.%u", pAddr->Address[2], pAddr->Address[3], pAddr->Address[4], pAddr->Address[5] );
// ipv6 sprintf( ba, "%u.%u.%u.%u.%u.%u", pAddr->Address[0], pAddr->Address[1], pAddr->Address[2], pAddr->Address[3], pAddr->Address[4], pAddr->Address[5] );
// --
if(( SesTyp == 1 )||( SesTyp == 2 )){
strcpy( bs, "Console" );
}else if(( SesTyp == 3 )||( SesTyp == 4 )){
strcpy( bs, "Remote" );
}else if(( SesTyp == 5 )||( SesTyp == 6 )){
strcpy( bs, "Logon" );
}else if(( SesTyp == 7 )||( SesTyp == 8 )){
strcpy( bs, "Lock" );
}else{
sprintf( bs, "Type-%u", SesTyp );
}
// --
if( strlen( ba ) < 8 ) strcpy( ba, "localhost" );
char pc[128]; // char *pc = malloc( sizeof( char ) * 64 );
ZeroMemory(&pc, 128 );
if( hostsize > 1 ) strcpy( pc, whost );
else strcpy( pc, "localhost" );
// --
if( SesTyp % 2 ){ // если не кратна двум то начало
sprintf( msg_err, "Begin Session Id-%i, Type-%i (%s), User:%s, Host:%s, IP:%s.", SesId, SesTyp, bs, wuser, pc, ba );
prn_log( msg_err );
if(( JOB > 100 )&&( SesTyp < 7 )) new_session( SesId, SesTyp, bs, wuser, token, pc, ba );
}else{
sprintf( msg_err, "End Session Id-%i, Type-%i (%s), User:%s.", SesId, SesTyp, bs, wuser );
prn_log( msg_err );
if(( JOB > 100 )&&( SesTyp < 7 )) end_session( SesId, SesTyp, bs, wuser );
}
// --
WTSFreeMemory( whost );
}
// --
WTSFreeMemory( bufa );
WTSFreeMemory( wuser );
}
}
void
client_read(struct bufferevent *bufev, void *arg)
{
struct session *s = arg;
size_t buf_avail, read;
int n;
do {
buf_avail = sizeof s->cbuf - s->cbuf_valid;
read = bufferevent_read(bufev, s->cbuf + s->cbuf_valid,
buf_avail);
s->cbuf_valid += read;
while ((n = get_line(s->cbuf, &s->cbuf_valid)) > 0) {
logmsg(LOG_DEBUG, "#%d client: %s", s->id, linebuf);
if (!client_parse(s)) {
end_session(s);
return;
}
bufferevent_write(s->server_bufev, linebuf, linelen);
}
if (n == -1) {
logmsg(LOG_ERR, "#%d client command too long or not"
" clean", s->id);
end_session(s);
return;
}
} while (read == buf_avail);
}
int process_input(void){
char input[MAX_INPUT];
char *inputp = input; char *newstr;
if (fgets(input, MAX_INPUT, stdin) != NULL){
if (input[0] == 'g' || input[0] == 's'){
end_session(0);
printf("\n");
} else if (input[0] == 'l' || input[0] == 'f'){
end_session(1);
if (strlen(input) > 3){
newstr = strstr(input, "l ");
if (newstr == NULL){
newstr = strstr(input, "f ");
}
if (newstr == NULL){ return 0; }
strncpy(newstr, "# ", 2);
fputs(newstr, sessfile);
}
return 0;
} else if (input[0] == 'r'){
time(&total_time);
printf("Resetting time");
} else {
printf("Invalid command: s[tatus], l{og} [message], r[eset]\n");
}
return 1;
}
}
void
server_read(struct bufferevent *bufev, void *arg)
{
struct session *s = arg;
size_t buf_avail, nread;
int n;
bufferevent_settimeout(bufev, timeout, 0);
do {
buf_avail = sizeof s->sbuf - s->sbuf_valid;
nread = bufferevent_read(bufev, s->sbuf + s->sbuf_valid,
buf_avail);
s->sbuf_valid += nread;
while ((n = get_line(s->sbuf, &s->sbuf_valid)) > 0) {
logmsg(LOG_DEBUG, "#%d server: %s", s->id, linebuf);
if (!server_parse(s)) {
end_session(s);
return;
}
bufferevent_write(s->client_bufev, linebuf, linelen);
}
if (n == -1) {
logmsg(LOG_ERR, "#%d server reply too long or not"
" clean", s->id);
end_session(s);
return;
}
} while (nread == buf_avail);
}
/*
* Callback upon receiving packet from network.
*/
static void on_read_complete(pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_read)
{
nat_detect_session *sess;
pj_status_t status;
sess = (nat_detect_session *) pj_ioqueue_get_user_data(key);
pj_assert(sess != NULL);
pj_grp_lock_acquire(sess->grp_lock);
/* Ignore packet when STUN session has been destroyed */
if (!sess->stun_sess)
goto on_return;
if (bytes_read < 0) {
if (-bytes_read != PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK) &&
-bytes_read != PJ_STATUS_FROM_OS(OSERR_EINPROGRESS) &&
-bytes_read != PJ_STATUS_FROM_OS(OSERR_ECONNRESET))
{
/* Permanent error */
end_session(sess, (pj_status_t)-bytes_read,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
goto on_return;
}
} else if (bytes_read > 0) {
pj_stun_session_on_rx_pkt(sess->stun_sess, sess->rx_pkt, bytes_read,
PJ_STUN_IS_DATAGRAM|PJ_STUN_CHECK_PACKET,
NULL, NULL,
&sess->src_addr, sess->src_addr_len);
}
sess->rx_pkt_len = sizeof(sess->rx_pkt);
sess->src_addr_len = sizeof(sess->src_addr);
status = pj_ioqueue_recvfrom(key, op_key, sess->rx_pkt, &sess->rx_pkt_len,
PJ_IOQUEUE_ALWAYS_ASYNC,
&sess->src_addr, &sess->src_addr_len);
if (status != PJ_EPENDING) {
pj_assert(status != PJ_SUCCESS);
end_session(sess, status, PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
}
on_return:
pj_grp_lock_release(sess->grp_lock);
}
void WINAPI ClosePanelW(const ClosePanelInfo* info) {
PluginInstance* plugin = (PluginInstance*) info->hPanel;
end_session(plugin);
// save last directory
if (g_plugin_options.save_last_dir) {
save_last_dir(plugin->device_info.strid(), plugin->current_dir);
}
g_plugin_objects.remove(g_plugin_objects.search(plugin));
delete plugin;
}
void
exit_daemon(void)
{
struct session *s, *next;
for (s = LIST_FIRST(&sessions); s != LIST_END(&sessions); s = next) {
next = LIST_NEXT(s, entry);
end_session(s);
}
if (daemonize)
closelog();
exit(0);
}
int main(int argc, char ** argv){
/* variables declaration */
int i;
int *size_of_buffer = 0;
int num_of_ones = 0;
/* Number of rounds that the algorithm will run */
int rounds = 0;
/* buffer that master will send */
char *buffer = NULL;
/* sessionC handler */
session *s;
join_session(&argc, &argv, &s, "Slave3.spr");
role *Master = s->get_role(s, "Master");
/* receive size of buffer */
receive_int(Master, &size_of_buffer);
printf("size of buffer is %d\n", *size_of_buffer);
/* Dynamic memory allocation */
buffer = (char *) malloc( (*size_of_buffer) * sizeof(char));
/* Receive the buffer */
receive_string(Master, &buffer);
/* For 100000 rounds */
while(rounds++ < 100000){
/* Compute the number of ones */
num_of_ones = number_of_ones(buffer);
}
printf("num of ones is %d\n", num_of_ones);
/* Send the result to the master node */
send_int(Master, num_of_ones);
/* Deallocate memory */
free(buffer);
/* End current session */
end_session(s);
return EXIT_SUCCESS;
}
void
client_error(struct bufferevent *bufev, short what, void *arg)
{
struct session *s = arg;
if (what & EVBUFFER_EOF)
logmsg(LOG_INFO, "#%d client close", s->id);
else if (what == (EVBUFFER_ERROR | EVBUFFER_READ))
logmsg(LOG_ERR, "#%d client reset connection", s->id);
else if (what & EVBUFFER_TIMEOUT)
logmsg(LOG_ERR, "#%d client timeout", s->id);
else if (what & EVBUFFER_WRITE)
logmsg(LOG_ERR, "#%d client write error: %d", s->id, what);
else
logmsg(LOG_ERR, "#%d abnormal client error: %d", s->id, what);
end_session(s);
}
void
server_error(struct bufferevent *bufev, short what, void *arg)
{
struct session *s = arg;
if (what & EVBUFFER_EOF)
logmsg(LOG_INFO, "#%d server close", s->id);
else if (what == (EVBUFFER_ERROR | EVBUFFER_READ))
logmsg(LOG_ERR, "#%d server refused connection", s->id);
else if (what & EVBUFFER_WRITE)
logmsg(LOG_ERR, "#%d server write error: %d", s->id, what);
else if (what & EVBUFFER_TIMEOUT)
logmsg(LOG_NOTICE, "#%d server timeout", s->id);
else
logmsg(LOG_ERR, "#%d abnormal server error: %d", s->id, what);
end_session(s);
}
int main(int argc, char *argv[])
{
char *line;
if(!argv[1]) {
error("baddr?");
exit(EXIT_FAILURE);
}
if(start_session(argv[1])==-1) {
error("failed to start session %s", argv[1]);
exit(EXIT_FAILURE);
}
int D;
info("GetLine");
while(getline(&line, &D, stdin) != -1) {
int x, y, b;
x = y = b = 0;
switch(*line) {
case 'x': x = strtol(&line[1], NULL, 0); break;
case 'y': y = strtol(&line[1], NULL, 0); break;
case 'b': b = strtol(&line[1], NULL, 0); break;
case 's': goto out;
}
info("Rep: %d %d %d",x,y,b);
if(send_mouse_report(x,y,b,0) == -1) {
error("Failed to send a report");
exit(EXIT_FAILURE);
}
}
info("Out");
out:
if(end_session()) {
error("Failed to end session");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
char *line;
if(!argv[1]) {
error("baddr?");
exit(EXIT_FAILURE);
}
if(start_session(argv[1]) == -1) {
error("failed to start session %s", argv[1]);
exit(EXIT_FAILURE);
}
while(getline(&line, NULL, stdin) != -1) {
int x, y, b;
x = y = b = 0;
switch(*line) {
case 'x':
x = strtol(&line[1], NULL, 0);
break;
case 'y':
y = strtol(&line[1], NULL, 0);
break;
case 'b':
b = strtol(&line[1], NULL, 0);
break;
case 's':
goto out;
}
}
out:
if(end_session()) {
error("Failed to end session");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
int ret = 1, istty, i, idx;
char *msg = NULL, *timer = NULL, *at_end = NULL, *halfway = NULL;
dldev_t dev;
tymer_t db;
u8 *data;
u16 len;
/* for data security */
/*
umask(S_IRWXG | S_IRWXO);
*/
istty = isatty(0);
i = strlen(argv[0]) - 1;
for(; i >= 0 && argv[0][i] != '/'; i--);
i++;
if(strstr(argv[0] + i, "interval")){
set_timer(POR_INTERVAL);
is_countdn = 0;
}
while((i = getopt(argc, argv, "hd:")) != -1){
switch(i){
case 'd':
dev_file = optarg;
break;
case 'h':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
#ifdef USB_USBHID
dev.usb.file = dev_file;
#endif
BEGIN_OPT()
OPT("msg", msg)
OPT("timer", timer)
OPT("at_end", at_end)
OPT("halfway", halfway)
END_OPT()
/* allows the user to change only at_end in interval timer */
if(istty && ((!msg || !timer) && (is_countdn || !at_end)))
usage();
if(open_dev(&dev)){
ERROR("open_dev");
goto exit;
}
if(start_session(&dev)){
ERROR("read_app_info");
goto exit;
}
/******************************************************************************/
#ifdef DEBUG
for(i = 0; i < NUM_APPS; i++){
if(!dev.app[i].acd.app_idx)
continue;
printf("%2d: %d%d%d%d%d%d%d%d %02x %02x %04x %04x %04x %04x %04x %04x %s\n", i,
dev.app[i].acd.app_idx,
dev.app[i].acd.code_loc,
dev.app[i].acd.db_loc,
dev.app[i].acd.code_invalid,
dev.app[i].acd.db_modified,
dev.app[i].acd.db_invalid,
dev.app[i].acd.passwd_req,
dev.app[i].acd.mode_name,
dev.app[i].acb.app_type,
dev.app[i].acb.app_inst,
dev.app[i].acb.asd_addr,
dev.app[i].acb.add_addr,
dev.app[i].acb.state_mgr_addr,
dev.app[i].acb.refresh_addr,
dev.app[i].acb.banner_addr,
dev.app[i].acb.code_addr,
dev.app[i].banner
);
}
#endif
/******************************************************************************/
if((idx = find_app(&dev, uapp_name)) < 0){
ERROR("%s application not found", uapp_name);
goto end;
}
if(dump_add(&dev, idx, &data, &len)){
ERROR("dump_add");
goto end;
}
read_timer(&db, data);
free(data);
if(!istty)
add_timer_file(&db, stdin);
if(msg && timer){
char buf[BUFSIZ];
timer_data_t rec;
sprintf(buf, "%s\t%s\t%s%s", msg, timer,
(at_end ? at_end : "stop"),
(halfway && strcmp(halfway, "no") ? "\thalfway" : ""));
if(read_timer_line(&rec, buf))
fprintf(stderr, "add_%s: format error!\n", lapp_name);
else
if(find_timer(&db, &rec) < 0)
add_timer(&db, &rec);
}
if(!is_countdn && at_end){
int i;
for(i = 0; i < 3 && strcmp(at_end, timer_at_end[i]); i++);
if(i < 3){
set_timer_at_end(i);
update_timer_at_end(&db);
}
}
create_timer(&db, &data, &len);
if(load_add(&dev, idx, data)){
ERROR("load_add");
goto end;
}
free(data);
print_timer(&db, stdout);
free_timer(&db);
/******************************************************************************/
end:
if(end_session(&dev)){
ERROR("end_session");
goto exit;
}
ret = 0;
exit:
close_dev(&dev);
exit(ret);
}
int main(int argc, char **argv){
/* Variables declaration */
int i;
int j;
/* Number of rounds to run the algorithm */
int rounds = 0;
/* Total size of the array */
int total_size = (rows * columns) / participants;
printf("Total amount of work is %d\n", total_size);
/* the amount of work that is assigned to worker1 */
int amount_of_work = floor( (worker1 + 1) * columns / participants ) - floor( worker1 * columns / participants );
printf("amount of work is %d\n", amount_of_work);
/* Session start */
session *s;
join_session(&argc, &argv, &s, "worker1.spr");
role *master = s->get_role(s, "master");
/* Dynamic memory allocation of array C */
int *C = NULL;
C = (int *) malloc(columns * sizeof(int));
if(C == NULL)
{
/* Terminate program if there is not enough memory */
fprintf(stderr, "out of memory \n");
exit(0);
}
/* Declaration of the main array */
int *Beta_worker1 = NULL;
/* Dynamic memory allocation */
Beta_worker1 = (int *) malloc( total_size * sizeof(int) );
/* Abort if there is not enough memory */
if(Beta_worker1 == NULL){
fprintf(stderr, "out of memory\n");
exit(-1);
}
/* The array that will hold the results */
int *worker1_results = NULL;
worker1_results = (int *) malloc( amount_of_work * sizeof(int) );
/* Fill with zeros the result array */
fill_with_zeros(worker1_results, amount_of_work);
/* The size of the arrays that master waits from the workers */
size_t array_C = columns;
size_t array_Beta = total_size;
/* worker1 receives the arrays in order to do the computation */
recv_int_array(master, C, &array_C);
recv_int_array(master, Beta_worker1, &array_Beta);
/* Run for 1000 rounds */
while(rounds++ < 1000){
/* Main computation from master */
for(i = 0; i < amount_of_work; i++)
for(j = 0; j < columns; j++)
worker1_results[i] += Beta_worker1[i * amount_of_work + j] * C[j];
}//End of while
/* worker1 sends the results to the master */
send_int_array(master, worker1_results, amount_of_work);
/* End Session */
end_session(s);
/* Deallocate memmory */
free(C);
C = NULL;
free(Beta_worker1);
Beta_worker1 = NULL;
free(worker1_results);
worker1_results = NULL;
return EXIT_SUCCESS;
}
/* Main function */
int main(int argc, char **argv){
/* Variables declaration */
int i;
int j;
/* The number of non zero elements */
int *num_of_no_zeros = NULL;
/* number of rounds */
int rounds = 0;
/* Session start */
session *s;
join_session(&argc, &argv, &s, "worker3.spr");
role *Master = s->get_role(s, "Master");
printf("I am here\n");
/* Receive number of non zero elements */
receive_int(Master, &num_of_no_zeros);
printf("NUm of zeros is %d\n", *num_of_no_zeros);
/* Number of non zero elements */
int no_zeros = *num_of_no_zeros;
/* Declaration and dynamic memory allocation af array row_ptr */
int *row_ptr = (int *) malloc((nrows + 1) * sizeof(int));
if(row_ptr == NULL){
fprintf(stderr, "Out of memory, aborting program...\n");
exit(-1);
}
/* Decalration and dynamic memory allocation af array values */
int *values = (int *) malloc(no_zeros * sizeof(int));
if(values == NULL){
fprintf(stderr, "Out of memory, aborting program...\n");
exit(-1);
}
/* Declaration and dynamic memory allocation af col_ind array */
int *col_ind = (int *) malloc(no_zeros * sizeof(int));
if(col_ind == NULL){
fprintf(stderr, "Out of memory, aborting program...\n");
exit(-1);
}
/* Declaration and dynamic memory allocation af x array */
int *x = (int *) malloc(ncolumns * sizeof(int));
if(x == NULL){
fprintf(stderr, "Out of memory, aborting program...\n");
exit(-1);
}
/* Expected size of array */
size_t sz_rows = 1001;
size_t sz_cols = 1000;
size_t sz_no_zeros = no_zeros;
/* Receive row_ptr from master */
recv_int_array(Master, row_ptr, &sz_rows);
/* Receive values array from master */
recv_int_array(Master, values, &sz_no_zeros);
/* Receive col_ind array from master */
recv_int_array(Master, col_ind, &sz_no_zeros);
/* Receive x array from master */
recv_int_array(Master, x, &sz_cols);
printf("value[%d] = %d\n", 0, values[0]);
/* The array that will hold the results of the main computation */
int *results = NULL;
/* Define the amount of work that worker 1 will do */
int start_work;
int end_work;
int amount_of_work;
/* The amount of work that the master will do */
start_work = floor((worker3 * nrows)/participants) / 10;
end_work = floor(((worker3 + 1) * nrows)/participants) / 10;
amount_of_work = (end_work - start_work);
printf("start = %d - end = %d - amount of work = %d\n", start_work, end_work, amount_of_work);
/* Declaration and dynamic memory allocation af x array */
results = (int *) malloc( 2 * amount_of_work * sizeof(int));
if(results == NULL){
fprintf(stderr, "Out of memory, aborting program...\n");
exit(-1);
}
/* Run for 100 rounds */
while(rounds++ < 10000){
/* Main computation of the result. Worker1
computes the work that is assigned to it*/
for(i = start_work; i < end_work; i++){
for(j = row_ptr[i]; j < row_ptr[i + 1]; j++)
results[i] += values[j] * x[col_ind[j]];
}
}
int array[amount_of_work];
for(i = 0; i < amount_of_work; i++)
array[i] = 0;
//send_int_array(Master, array, amount_of_work);
//printf("here i am \n");
/* Send the results to the master */
//send_int_array(Master, values, amount_of_work);
send_int_array(Master, results, amount_of_work);
//send_int(Master, amount_of_work);
//recv_int_array(Master, col_ind, &sz_no_zeros);
printf("gamw!!!\n");
/* End current session */
end_session(s);
/* Free memory */
free(row_ptr);
row_ptr = NULL;
free(values);
values = NULL;
free(col_ind);
col_ind = NULL;
free(x);
x = NULL;
free(results);
results = NULL;
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
int ret = 1, i;
char *tz[3], *date = NULL, *hr24 = NULL, *week_no = NULL, *dst = NULL,
*euro = NULL, *observe_dst = NULL, *adjust = NULL;
u8 date_format_;
time_t dsec[3], adjust_sec = 0;
time_t tloc, tloc2;
struct tm *tm;
dldev_t dev;
tod_t db;
/* for data security */
/*
umask(S_IRWXG | S_IRWXO);
*/
while((i = getopt(argc, argv, "hd:")) != -1){
switch(i){
case 'd':
dev_file = optarg;
break;
case 'h':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
#ifdef USB_USBHID
dev.usb.file = dev_file;
#endif
memset(tz, 0, sizeof(tz));
BEGIN_OPT()
OPT("tz1", tz[0])
OPT("tz2", tz[1])
OPT("tz3", tz[2])
OPT("date", date)
OPT("24hr", hr24)
OPT("week_no", week_no)
OPT("dst", dst)
OPT("euro", euro)
OPT("observe_dst", observe_dst)
/* non-standard options */
OPT("adjust", adjust)
END_OPT()
if(date){
for(i = 0; i < 3 && strcmp(date, date_format[i]); i++);
if(i == 3){
fprintf(stderr, "%s: format error!\n", date);
usage();
}
date_format_ = i;
}else
date_format_ = mdy;
for(i = 0; i < 3; i++){
dsec[i] = 0;
if(tz[i] && tz[i][0]){
char buf[10];
strncpy(buf, tz[i], 9);
buf[9] = 0;
if(strlen(buf) != 9 ||
(buf[3] != '+' && buf[3] != '-')){
fprintf(stderr, "%s: format error!\n", tz[i]);
usage();
}
buf[6] = 0;
dsec[i] = atoi(buf+3) * 3600 + atoi(buf+7) * 60;
}
}
if(adjust && adjust[0]){
char buf[10];
strncpy(buf, adjust, 9);
buf[9] = 0;
if(strlen(buf) != 9 || (buf[0] != '+' && buf[0] != '-')){
fprintf(stderr, "%s: format error!\n", adjust);
usage();
}
buf[3] = buf[6] = 0;
adjust_sec = atoi(buf) * 3600 + atoi(buf+4) * 60 + atoi(buf+7);
}
if(open_dev(&dev)){
ERROR("open_dev");
goto exit;
}
if(start_session(&dev)){
ERROR("read_app_info");
goto exit;
}
/******************************************************************************/
#ifdef DEBUG
for(i = 0; i < NUM_APPS; i++){
if(!dev.app[i].acd.app_idx)
continue;
printf("%2d: %d%d%d%d%d%d%d%d %02x %02x %04x %04x %04x %04x %04x %04x %s\n", i,
dev.app[i].acd.app_idx,
dev.app[i].acd.code_loc,
dev.app[i].acd.db_loc,
dev.app[i].acd.code_invalid,
dev.app[i].acd.db_modified,
dev.app[i].acd.db_invalid,
dev.app[i].acd.passwd_req,
dev.app[i].acd.mode_name,
dev.app[i].acb.app_type,
dev.app[i].acb.app_inst,
dev.app[i].acb.asd_addr,
dev.app[i].acb.add_addr,
dev.app[i].acb.state_mgr_addr,
dev.app[i].acb.refresh_addr,
dev.app[i].acb.banner_addr,
dev.app[i].acb.code_addr,
dev.app[i].banner
);
}
#endif
/******************************************************************************/
time(&tloc);
memset(&db, 0, sizeof(tod_t));
for(i = 0; i < 3; i++){
db.tod[i].primary = !i; /* user */
db.tod[i].update_tz_id = 1; /* -> tz_id */
db.tod[i].update_display = 1; /* -> everything else? */
db.tod[i].update_tz_name = 1; /* -> tz_name */
db.tod[i].update_hms = 1; /* -> hour/minute/second */
db.tod[i].update_mdy = 1; /* -> year/month/day */
/* update_display */
db.tod[i].date_format = date_format_; /* user */
db.tod[i].hr24_format = (hr24 && strcmp(hr24, "no")); /* user */
db.tod[i].display_week_no = (week_no && strcmp(week_no, "no"));
/* user */
db.tod[i].tz_in_dst = (dst && strcmp(dst, "no")); /* user */
db.tod[i].euro_format = (euro && strcmp(euro, "no")); /* user */
db.tod[i].tz_observes_dst =
(observe_dst && strcmp(observe_dst, "no")); /* user */
/* set if update_mdy = 1 */
db.tod[i].tz_entered_set_state = 1;
/* update_tz_name */
if(tz[i] && tz[i][0])
strncpy(db.tod[i].tz_name, tz[i], 3); /* user */
else
strncpy(db.tod[i].tz_name, "UTC", 3); /* user */
/* update_tz_id */
db.tod[i].tz_id = 0; /* used for WorldTime WristApp */
tloc2 = tloc + dsec[i] + adjust_sec;
tm = gmtime(&tloc2);
/* update_hms */
db.tod[i].second = tm->tm_sec; /* user */
db.tod[i].minute = tm->tm_min; /* user */
db.tod[i].hour = tm->tm_hour; /* user */
/* update_mdy */
db.tod[i].day = tm->tm_mday; /* user */
db.tod[i].month = tm->tm_mon + 1; /* user */
db.tod[i].year = tm->tm_year + 1900; /* user */
}
if(update_tod(&dev, &db)){
ERROR("update_tod");
goto end;
}
/******************************************************************************/
end:
if(end_session(&dev)){
ERROR("end_session");
goto exit;
}
ret = 0;
exit:
close_dev(&dev);
exit(ret);
}
/*
* Callback upon request completion.
*/
static void on_request_complete(pj_stun_session *stun_sess,
pj_status_t status,
void *token,
pj_stun_tx_data *tdata,
const pj_stun_msg *response,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len)
{
nat_detect_session *sess;
pj_stun_sockaddr_attr *mattr = NULL;
pj_stun_changed_addr_attr *ca = NULL;
pj_uint32_t *tsx_id;
int cmp;
unsigned test_id;
PJ_UNUSED_ARG(token);
PJ_UNUSED_ARG(tdata);
PJ_UNUSED_ARG(src_addr);
PJ_UNUSED_ARG(src_addr_len);
sess = (nat_detect_session*) pj_stun_session_get_user_data(stun_sess);
pj_grp_lock_acquire(sess->grp_lock);
/* Find errors in the response */
if (status == PJ_SUCCESS) {
/* Check error message */
if (PJ_STUN_IS_ERROR_RESPONSE(response->hdr.type)) {
pj_stun_errcode_attr *eattr;
int err_code;
eattr = (pj_stun_errcode_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_ERROR_CODE, 0);
if (eattr != NULL)
err_code = eattr->err_code;
else
err_code = PJ_STUN_SC_SERVER_ERROR;
status = PJ_STATUS_FROM_STUN_CODE(err_code);
} else {
/* Get MAPPED-ADDRESS or XOR-MAPPED-ADDRESS */
mattr = (pj_stun_sockaddr_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_XOR_MAPPED_ADDR, 0);
if (mattr == NULL) {
mattr = (pj_stun_sockaddr_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_MAPPED_ADDR, 0);
}
if (mattr == NULL) {
status = PJNATH_ESTUNNOMAPPEDADDR;
}
/* Get CHANGED-ADDRESS attribute */
ca = (pj_stun_changed_addr_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_CHANGED_ADDR, 0);
if (ca == NULL) {
status = PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_SERVER_ERROR);
}
}
}
/* Save the result */
tsx_id = (pj_uint32_t*) tdata->msg->hdr.tsx_id;
test_id = tsx_id[2];
if (test_id >= ST_MAX) {
PJ_LOG(4,(sess->pool->obj_name, "Invalid transaction ID %u in response",
test_id));
end_session(sess, PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_SERVER_ERROR),
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
goto on_return;
}
PJ_LOG(5,(sess->pool->obj_name, "Completed %s, status=%d",
test_names[test_id], status));
sess->result[test_id].complete = PJ_TRUE;
sess->result[test_id].status = status;
if (status == PJ_SUCCESS) {
pj_memcpy(&sess->result[test_id].ma, &mattr->sockaddr.ipv4,
sizeof(pj_sockaddr_in));
pj_memcpy(&sess->result[test_id].ca, &ca->sockaddr.ipv4,
sizeof(pj_sockaddr_in));
}
/* Send Test 1B only when Test 2 completes. Must not send Test 1B
* before Test 2 completes to avoid creating mapping on the NAT.
*/
if (!sess->result[ST_TEST_1B].executed &&
sess->result[ST_TEST_2].complete &&
sess->result[ST_TEST_2].status != PJ_SUCCESS &&
sess->result[ST_TEST_1].complete &&
sess->result[ST_TEST_1].status == PJ_SUCCESS)
{
cmp = pj_memcmp(&sess->local_addr, &sess->result[ST_TEST_1].ma,
sizeof(pj_sockaddr_in));
if (cmp != 0)
send_test(sess, ST_TEST_1B, &sess->result[ST_TEST_1].ca, 0);
}
if (test_completed(sess)<3 || test_completed(sess)!=test_executed(sess))
goto on_return;
/* Handle the test result according to RFC 3489 page 22:
+--------+
| Test |
| 1 |
+--------+
|
|
V
/\ /\
N / \ Y / \ Y +--------+
UDP <-------/Resp\--------->/ IP \------------->| Test |
Blocked \ ? / \Same/ | 2 |
\ / \? / +--------+
\/ \/ |
| N |
| V
V /\
+--------+ Sym. N / \
| Test | UDP <---/Resp\
| 2 | Firewall \ ? /
+--------+ \ /
| \/
V |Y
/\ /\ |
Symmetric N / \ +--------+ N / \ V
NAT <--- / IP \<-----| Test |<--- /Resp\ Open
\Same/ | 1B | \ ? / Internet
\? / +--------+ \ /
\/ \/
| |Y
| |
| V
| Full
| Cone
V /\
+--------+ / \ Y
| Test |------>/Resp\---->Restricted
| 3 | \ ? /
+--------+ \ /
\/
|N
| Port
+------>Restricted
Figure 2: Flow for type discovery process
*/
switch (sess->result[ST_TEST_1].status) {
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 1 has timed-out. Conclude with NAT_TYPE_BLOCKED.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_BLOCKED);
break;
case PJ_SUCCESS:
/*
* Test 1 is successful. Further tests are needed to detect
* NAT type. Compare the MAPPED-ADDRESS with the local address.
*/
cmp = pj_memcmp(&sess->local_addr, &sess->result[ST_TEST_1].ma,
sizeof(pj_sockaddr_in));
if (cmp==0) {
/*
* MAPPED-ADDRESS and local address is equal. Need one more
* test to determine NAT type.
*/
switch (sess->result[ST_TEST_2].status) {
case PJ_SUCCESS:
/*
* Test 2 is also successful. We're in the open.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_OPEN);
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 2 has timed out. We're behind somekind of UDP
* firewall.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_SYMMETRIC_UDP);
break;
default:
/*
* We've got other error with Test 2.
*/
end_session(sess, sess->result[ST_TEST_2].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
} else {
/*
* MAPPED-ADDRESS is different than local address.
* We're behind NAT.
*/
switch (sess->result[ST_TEST_2].status) {
case PJ_SUCCESS:
/*
* Test 2 is successful. We're behind a full-cone NAT.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_FULL_CONE);
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 2 has timed-out Check result of test 1B..
*/
switch (sess->result[ST_TEST_1B].status) {
case PJ_SUCCESS:
/*
* Compare the MAPPED-ADDRESS of test 1B with the
* MAPPED-ADDRESS returned in test 1..
*/
cmp = pj_memcmp(&sess->result[ST_TEST_1].ma,
&sess->result[ST_TEST_1B].ma,
sizeof(pj_sockaddr_in));
if (cmp != 0) {
/*
* MAPPED-ADDRESS is different, we're behind a
* symmetric NAT.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_SYMMETRIC);
} else {
/*
* MAPPED-ADDRESS is equal. We're behind a restricted
* or port-restricted NAT, depending on the result of
* test 3.
*/
switch (sess->result[ST_TEST_3].status) {
case PJ_SUCCESS:
/*
* Test 3 is successful, we're behind a restricted
* NAT.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_RESTRICTED);
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 3 failed, we're behind a port restricted
* NAT.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_PORT_RESTRICTED);
break;
default:
/*
* Got other error with test 3.
*/
end_session(sess, sess->result[ST_TEST_3].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
}
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Strangely test 1B has failed. Maybe connectivity was
* lost? Or perhaps port 3489 (the usual port number in
* CHANGED-ADDRESS) is blocked?
*/
switch (sess->result[ST_TEST_3].status) {
case PJ_SUCCESS:
/* Although test 1B failed, test 3 was successful.
* It could be that port 3489 is blocked, while the
* NAT itself looks to be a Restricted one.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_RESTRICTED);
break;
default:
/* Can't distinguish between Symmetric and Port
* Restricted, so set the type to Unknown
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
break;
default:
/*
* Got other error with test 1B.
*/
end_session(sess, sess->result[ST_TEST_1B].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
break;
default:
/*
* We've got other error with Test 2.
*/
end_session(sess, sess->result[ST_TEST_2].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
}
break;
default:
/*
* We've got other error with Test 1.
*/
end_session(sess, sess->result[ST_TEST_1].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
on_return:
pj_grp_lock_release(sess->grp_lock);
}
int
main(int argc, char *argv[])
{
int ret = 1, istty, i, idx, delete_all = 0, updated = 0;
dldev_t dev;
contact_t db;
contact_data_t rec;
u8 *data;
u16 len;
/* for data security */
/*
umask(S_IRWXG | S_IRWXO);
*/
istty = isatty(0);
while((i = getopt(argc, argv, "hd:a")) != -1){
switch(i){
case 'd':
dev_file = optarg;
break;
case 'a':
delete_all = 1;
break;
case 'h':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
#ifdef USB_USBHID
dev.usb.file = dev_file;
#endif
memset(&rec, 0, sizeof(contact_data_t));
BEGIN_OPT()
OPT("msg", rec.msg)
OPT("type", rec.type)
OPT("area", rec.area)
OPT("number", rec.number)
END_OPT()
if(delete_all){
fprintf(stderr,
"WARNING: DELETE ALL CONTACTS IN THE WATCH (Y/N)? ");
if(tolower(getchar()) != 'y')
exit(0);
}else
if(istty && (!rec.msg || !rec.type || !rec.area || !rec.number))
usage();
/* TODO: long phone number extending to the next or previous record */
if(open_dev(&dev)){
ERROR("open_dev");
goto exit;
}
if(start_session(&dev)){
ERROR("read_app_info");
goto exit;
}
/******************************************************************************/
#ifdef DEBUG
for(i = 0; i < NUM_APPS; i++){
if(!dev.app[i].acd.app_idx)
continue;
printf("%2d: %d%d%d%d%d%d%d%d %02x %02x %04x %04x %04x %04x %04x %04x %s\n", i,
dev.app[i].acd.app_idx,
dev.app[i].acd.code_loc,
dev.app[i].acd.db_loc,
dev.app[i].acd.code_invalid,
dev.app[i].acd.db_modified,
dev.app[i].acd.db_invalid,
dev.app[i].acd.passwd_req,
dev.app[i].acd.mode_name,
dev.app[i].acb.app_type,
dev.app[i].acb.app_inst,
dev.app[i].acb.asd_addr,
dev.app[i].acb.add_addr,
dev.app[i].acb.state_mgr_addr,
dev.app[i].acb.refresh_addr,
dev.app[i].acb.banner_addr,
dev.app[i].acb.code_addr,
dev.app[i].banner
);
}
#endif
/******************************************************************************/
if((idx = find_app(&dev, "CONTACT")) < 0){
ERROR("CONTACT application not found");
goto end;
}
if(dump_add(&dev, idx, &data, &len)){
ERROR("dump_add");
goto end;
}
read_contact(&db, data);
free(data);
if(delete_all){
while(!del_contact(&db, 0))
updated = 1;
}else{
if(!istty && !del_contact_file(&db, stdin))
updated = 1;
if(rec.msg && rec.type && rec.area && rec.number &&
(i = find_contact(&db, &rec)) >= 0 &&
!del_contact(&db, i))
updated = 1;
}
if(updated){
create_contact(&db, &data, &len);
if(load_add(&dev, idx, data)){
ERROR("load_add");
goto end;
}
free(data);
}
print_contact(&db, stdout);
free_contact(&db);
/******************************************************************************/
end:
if(end_session(&dev)){
ERROR("end_session");
goto exit;
}
ret = 0;
exit:
close_dev(&dev);
exit(ret);
}
/**
* Author: Joel Denke, Marcus Isaksson
* Description: Run the game on client
*/
int main(int argc, char *argv[])
{
int i, j, no, yb, keysHeld[323] = {0};
int result = 0;
SDL_Thread * eventBuffer;
SDL_Thread * runBuffer;
struct timer_t2 fps;
char * server_ip = malloc(sizeof(char) * 16);
char * elem = malloc(sizeof(char) * MESSAGE_SIZE);
pColor = malloc(sizeof(SDL_Color));
oColor = malloc(sizeof(SDL_Color));
connection = malloc(sizeof(connection_data));
for (i = 0; i < NO_BUFFERS; i++) {
cb[i] = malloc(sizeof(cBuffer));
b_lock[i] = SDL_CreateMutex();
}
strcpy(server_ip, "127.0.0.1");
pColor->r = 0;
pColor->g = 255;
pColor->b = 255;
oColor->r = 0;
oColor->g = 0;
oColor->b = 255;
initGraphics();
initSound();
printf("Render menu\n");
graphicsMenu(&gameWorld, server_ip);
initSlots(cb[0], BUFFER_SIZE);
initSlots(cb[1], NO_OBJECTS);
initSlots(cb[2], BUFFER_SIZE);
state = gStart;
if (clientConnect(connection, server_ip) == 0)
{
eventBuffer = SDL_CreateThread(listenEventBuffer, &connection);
while (1) {
switch (state) {
case gStart:
runData(2);
break;
case gInit:
timer_start(&fps);
startDraw();
drawLoadScr(SCREEN_WIDTH, SCREEN_HEIGHT);
endDraw();
initWorld();
if (timer_get_ticks(&fps) < 1000 / FPS)
{
//delay the as much time as we need to get desired frames per second
SDL_Delay( ( 1000 / FPS ) - timer_get_ticks(&fps) );
}
break;
case gRunning :
timer_start(&fps);
drawGraphics();
listenInput(keysHeld);
// i = 0: players; i = 1: objects; i = 2: messages
for (i = 0; i < NO_BUFFERS; i++) {
runData(i);
}
if (timer_get_ticks(&fps) < 1000 / FPS)
{
//delay the as much time as we need to get desired frames per second
SDL_Delay( ( 1000 / FPS ) - timer_get_ticks(&fps) );
}
break;
case gExit :
//sprintf(string, "%d,quit", connection->client_id);
printf("Freeing music now\n");
pauseMusic();
freeMusic();
end_session(connection);
printf("Player is exit game now\n");
exitClient(eventBuffer);
break;
default :
printf("test\n");
break;
}
}
} else {
printf("Misslyckade med att kontakta servern på ip-adress: '%s'\n", server_ip);
state = gExit;
pauseMusic();
freeMusic();
exitClient(eventBuffer);
}
return 0;
}
int
main(int argc, char *argv[])
{
int ret = 1, i, idx, fd, num_apps = 0;
char *dev_file = "/dev/uhid0", *banner, *file;
dldev_t dev;
appinfo *app = NULL;
u8 *data;
u16 len;
/* for data security */
/*
umask(S_IRWXG | S_IRWXO);
*/
while((i = getopt(argc, argv, "hd:")) != -1){
switch(i){
case 'd':
dev_file = optarg;
break;
case 'h':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
#ifdef USB_USBHID
dev.usb.file = dev_file;
#endif
BEGIN_OPT()
APP_OPT("rom", -3)
APP_OPT("eeprom", -2)
APP_OPT("wristapp", -1)
APP_OPT("contact", APP_CONTACT)
APP_OPT("note", APP_NOTE)
APP_OPT("appt", APP_APPT)
APP_OPT("alarm", APP_ALARM)
APP_OPT("schedule", APP_SCHEDULE)
APP_OPT("occasion", APP_OCCASION)
APP_OPT("chrono", APP_CHRONO)
APP_OPT("countdn", APP_TIMER)
APP_OPT("interval", APP_TIMER | 0x100)
#if 0
APP_OPT("synchro", APP_SYNCHRO)
#endif
APP_OPT("option", APP_OPTION)
END_OPT()
if(!num_apps)
usage();
if(open_dev(&dev)){
ERROR("open_dev");
goto exit;
}
tucp_progress(1);
if(start_session(&dev)){
ERROR("read_app_info");
goto exit;
}
/******************************************************************************/
#ifdef DEBUG
for(i = 0; i < NUM_APPS; i++){
if(!dev.app[i].acd.app_idx)
continue;
printf("%2d: %d%d%d%d%d%d%d%d %02x %02x %04x %04x %04x %04x %04x %04x %s\n", i,
dev.app[i].acd.app_idx,
dev.app[i].acd.code_loc,
dev.app[i].acd.db_loc,
dev.app[i].acd.code_invalid,
dev.app[i].acd.db_modified,
dev.app[i].acd.db_invalid,
dev.app[i].acd.passwd_req,
dev.app[i].acd.mode_name,
dev.app[i].acb.app_type,
dev.app[i].acb.app_inst,
dev.app[i].acb.asd_addr,
dev.app[i].acb.add_addr,
dev.app[i].acb.state_mgr_addr,
dev.app[i].acb.refresh_addr,
dev.app[i].acb.banner_addr,
dev.app[i].acb.code_addr,
dev.app[i].banner
);
}
#endif
/******************************************************************************/
for(i = 0; i < num_apps; i++){
if(app[i].file[0])
fprintf(stderr, "%s\n", app[i].file);
else
continue;
banner = NULL;
file = app[i].file;
switch(app[i].app){
case -3:
if(dump_rom(&dev, &data, &len)){
ERROR("dump_rom");
goto end;
}
break;
case -2:
if(dump_eeprom(&dev, &data, &len)){
ERROR("dump_eeprom");
goto end;
}
break;
case -1:
banner = file;
for(; *file && *file != '='; file++);
if(*file)
*file++ = 0;
if(!(*file)){
ERROR("%s: no file name specified", banner);
goto end;
}
for(; *banner; banner++)
*banner = toupper(*banner);
banner = app[i].file;
break;
case APP_CONTACT:
banner = "CONTACT";
break;
case APP_NOTE:
banner = "NOTE";
break;
case APP_APPT:
banner = "APPT";
break;
case APP_ALARM:
banner = "ALARM";
break;
case APP_SCHEDULE:
banner = "SCHEDULE";
break;
case APP_OCCASION:
banner = "OCCASION";
break;
case APP_CHRONO:
banner = "CHRONO";
break;
case APP_TIMER:
banner = "COUNTDN TIMER";
break;
case APP_TIMER | 0x100:
banner = "INTERVAL TIMER";
break;
#if 0
case APP_SYNCHRO:
banner = "SYNCHRO";
break;
#endif
case APP_OPTION:
len = 15;
data = (u8 *)malloc(len);
if(read_abs_addr(&dev, dev.sysmap.opt_addr, int_mem,
data, len)){
ERROR("read_abs_addr");
goto end;
}
break;
}
if(banner){
if((idx = find_app(&dev, banner)) < 0){
ERROR("%s application not found", banner);
goto end;
}
if(dump_add(&dev, idx, &data, &len)){
ERROR("dump_add");
goto end;
}
}
if((fd = open(file, O_WRITE, S_IRWUSR)) < 0){
ERROR("%s: open failed", file);
goto end;
}
if(write(fd, data, len) != len){
ERROR("%s: write failed", file);
goto end;
}
close(fd);
free(data);
}
/******************************************************************************/
end:
if(end_session(&dev)){
ERROR("end_session");
goto exit;
}
tucp_progress(0);
ret = 0;
exit:
close_dev(&dev);
exit(ret);
}
int
main(int argc, char *argv[])
{
int ret = 1, i;
dldev_t dev;
note_t db;
u8 *data;
u16 len;
/* for data security */
/*
umask(S_IRWXG | S_IRWXO);
*/
while((i = getopt(argc, argv, "hd:u:e:")) != -1){
switch(i){
case 'd':
dev_file = optarg;
break;
case 'u':
unused_recs = atoi(optarg);
if(unused_recs < 0)
unused_recs = 0;
break;
case 'e':
extra_msg_len = atoi(optarg);
if(extra_msg_len < 0)
extra_msg_len = 0;
break;
case 'h':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
set_note_unused_recs(unused_recs);
set_note_extra_len(extra_msg_len);
#ifdef USB_USBHID
dev.usb.file = dev_file;
#endif
if(open_dev(&dev)){
ERROR("open_dev");
goto exit;
}
if(start_session(&dev)){
ERROR("read_app_info");
goto exit;
}
/******************************************************************************/
#ifdef DEBUG
for(i = 0; i < NUM_APPS; i++){
if(!dev.app[i].acd.app_idx)
continue;
printf("%2d: %d%d%d%d%d%d%d%d %02x %02x %04x %04x %04x %04x %04x %04x %s\n", i,
dev.app[i].acd.app_idx,
dev.app[i].acd.code_loc,
dev.app[i].acd.db_loc,
dev.app[i].acd.code_invalid,
dev.app[i].acd.db_modified,
dev.app[i].acd.db_invalid,
dev.app[i].acd.passwd_req,
dev.app[i].acd.mode_name,
dev.app[i].acb.app_type,
dev.app[i].acb.app_inst,
dev.app[i].acb.asd_addr,
dev.app[i].acb.add_addr,
dev.app[i].acb.state_mgr_addr,
dev.app[i].acb.refresh_addr,
dev.app[i].acb.banner_addr,
dev.app[i].acb.code_addr,
dev.app[i].banner
);
}
#endif
/******************************************************************************/
if(read_note_mem(&dev, &db)){
ERROR("read_note_mem");
goto end;
}
create_note(&db, &data, &len);
if(load_add(&dev, find_app(&dev, "NOTE"), data)){
ERROR("load_add");
goto end;
}
free(data);
print_note(&db, stdout);
free_note(&db);
/******************************************************************************/
end:
if(end_session(&dev)){
ERROR("end_session");
goto exit;
}
ret = 0;
exit:
close_dev(&dev);
exit(ret);
}
int
main(int argc, char *argv[])
{
int ret = 1, i, idx;
dldev_t dev;
tymer_t db;
u8 *data;
u16 len;
/* for data security */
/*
umask(S_IRWXG | S_IRWXO);
*/
i = strlen(argv[0]) - 1;
for(; i >= 0 && argv[0][i] != '/'; i--);
i++;
if(strstr(argv[0] + i, "interval")){
set_timer(POR_INTERVAL);
is_countdn = 0;
}
while((i = getopt(argc, argv, "hd:")) != -1){
switch(i){
case 'd':
dev_file = optarg;
break;
case 'h':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
#ifdef USB_USBHID
dev.usb.file = dev_file;
#endif
if(open_dev(&dev)){
ERROR("open_dev");
goto exit;
}
if(start_session(&dev)){
ERROR("read_app_info");
goto exit;
}
/******************************************************************************/
#ifdef DEBUG
for(i = 0; i < NUM_APPS; i++){
if(!dev.app[i].acd.app_idx)
continue;
printf("%2d: %d%d%d%d%d%d%d%d %02x %02x %04x %04x %04x %04x %04x %04x %s\n", i,
dev.app[i].acd.app_idx,
dev.app[i].acd.code_loc,
dev.app[i].acd.db_loc,
dev.app[i].acd.code_invalid,
dev.app[i].acd.db_modified,
dev.app[i].acd.db_invalid,
dev.app[i].acd.passwd_req,
dev.app[i].acd.mode_name,
dev.app[i].acb.app_type,
dev.app[i].acb.app_inst,
dev.app[i].acb.asd_addr,
dev.app[i].acb.add_addr,
dev.app[i].acb.state_mgr_addr,
dev.app[i].acb.refresh_addr,
dev.app[i].acb.banner_addr,
dev.app[i].acb.code_addr,
dev.app[i].banner
);
}
#endif
/******************************************************************************/
if((idx = find_app(&dev, uapp_name)) < 0){
ERROR("%s application not found", uapp_name);
goto end;
}
if(dump_add(&dev, idx, &data, &len)){
ERROR("dump_add");
goto end;
}
read_timer(&db, data);
free(data);
print_timer(&db, stdout);
free_timer(&db);
/******************************************************************************/
end:
if(end_session(&dev)){
ERROR("end_session");
goto exit;
}
ret = 0;
exit:
close_dev(&dev);
exit(ret);
}
void
handle_connection(const int listen_fd, short event, void *arg)
{
struct sockaddr_storage tmp_ss;
struct sockaddr *client_sa, *server_sa, *fixed_server_sa;
struct sockaddr *proxy_to_server_sa;
struct session *s;
socklen_t len;
int client_fd, fc, on;
event_add(&listen_ev, NULL);
if ((event & EV_TIMEOUT))
/* accept() is no longer paused. */
return;
/*
* We _must_ accept the connection, otherwise libevent will keep
* coming back, and we will chew up all CPU.
*/
client_sa = sstosa(&tmp_ss);
len = sizeof(struct sockaddr_storage);
if ((client_fd = accept(listen_fd, client_sa, &len)) < 0) {
logmsg(LOG_CRIT, "accept() failed: %s", strerror(errno));
/*
* Pause accept if we are out of file descriptors, or
* libevent will haunt us here too.
*/
if (errno == ENFILE || errno == EMFILE) {
struct timeval pause = { 1, 0 };
event_del(&listen_ev);
evtimer_add(&pause_accept_ev, &pause);
} else if (errno != EWOULDBLOCK && errno != EINTR &&
errno != ECONNABORTED)
logmsg(LOG_CRIT, "accept() failed: %s", strerror(errno));
return;
}
/* Refuse connection if the maximum is reached. */
if (session_count >= max_sessions) {
logmsg(LOG_ERR, "client limit (%d) reached, refusing "
"connection from %s", max_sessions, sock_ntop(client_sa));
close(client_fd);
return;
}
/* Allocate session and copy back the info from the accept(). */
s = init_session();
if (s == NULL) {
logmsg(LOG_CRIT, "init_session failed");
close(client_fd);
return;
}
s->client_fd = client_fd;
memcpy(sstosa(&s->client_ss), client_sa, client_sa->sa_len);
/* Cast it once, and be done with it. */
client_sa = sstosa(&s->client_ss);
server_sa = sstosa(&s->server_ss);
proxy_to_server_sa = sstosa(&s->proxy_ss);
fixed_server_sa = sstosa(&fixed_server_ss);
/* Log id/client early to ease debugging. */
logmsg(LOG_DEBUG, "#%d accepted connection from %s", s->id,
sock_ntop(client_sa));
/*
* Find out the real server and port that the client wanted.
*/
len = sizeof(struct sockaddr_storage);
if (getsockname(s->client_fd, server_sa, &len) < 0) {
logmsg(LOG_CRIT, "#%d getsockname failed: %s", s->id,
strerror(errno));
goto fail;
}
len = sizeof(s->client_rd);
if (getsockopt(s->client_fd, SOL_SOCKET, SO_RTABLE, &s->client_rd,
&len) && errno != ENOPROTOOPT) {
logmsg(LOG_CRIT, "#%d getsockopt failed: %s", s->id,
strerror(errno));
goto fail;
}
if (fixed_server) {
memcpy(sstosa(&s->orig_server_ss), server_sa,
server_sa->sa_len);
memcpy(server_sa, fixed_server_sa, fixed_server_sa->sa_len);
}
/* XXX: check we are not connecting to ourself. */
/*
* Setup socket and connect to server.
*/
if ((s->server_fd = socket(server_sa->sa_family, SOCK_STREAM,
IPPROTO_TCP)) < 0) {
logmsg(LOG_CRIT, "#%d server socket failed: %s", s->id,
strerror(errno));
goto fail;
}
if (fixed_proxy && bind(s->server_fd, sstosa(&fixed_proxy_ss),
fixed_proxy_ss.ss_len) != 0) {
logmsg(LOG_CRIT, "#%d cannot bind fixed proxy address: %s",
s->id, strerror(errno));
goto fail;
}
/* Use non-blocking connect(), see CONNECT_TIMEOUT below. */
if ((fc = fcntl(s->server_fd, F_GETFL)) == -1 ||
fcntl(s->server_fd, F_SETFL, fc | O_NONBLOCK) == -1) {
logmsg(LOG_CRIT, "#%d cannot mark socket non-blocking: %s",
s->id, strerror(errno));
goto fail;
}
if (connect(s->server_fd, server_sa, server_sa->sa_len) < 0 &&
errno != EINPROGRESS) {
logmsg(LOG_CRIT, "#%d proxy cannot connect to server %s: %s",
s->id, sock_ntop(server_sa), strerror(errno));
goto fail;
}
len = sizeof(struct sockaddr_storage);
if ((getsockname(s->server_fd, proxy_to_server_sa, &len)) < 0) {
logmsg(LOG_CRIT, "#%d getsockname failed: %s", s->id,
strerror(errno));
goto fail;
}
logmsg(LOG_INFO, "#%d FTP session %d/%d started: client %s to server "
"%s via proxy %s", s->id, session_count, max_sessions,
sock_ntop(client_sa), sock_ntop(server_sa),
sock_ntop(proxy_to_server_sa));
/* Keepalive is nice, but don't care if it fails. */
on = 1;
setsockopt(s->client_fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&on,
sizeof on);
setsockopt(s->server_fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&on,
sizeof on);
/*
* Setup buffered events.
*/
s->client_bufev = bufferevent_new(s->client_fd, &client_read, NULL,
&client_error, s);
if (s->client_bufev == NULL) {
logmsg(LOG_CRIT, "#%d bufferevent_new client failed", s->id);
goto fail;
}
bufferevent_settimeout(s->client_bufev, timeout, 0);
bufferevent_enable(s->client_bufev, EV_READ | EV_TIMEOUT);
s->server_bufev = bufferevent_new(s->server_fd, &server_read, NULL,
&server_error, s);
if (s->server_bufev == NULL) {
logmsg(LOG_CRIT, "#%d bufferevent_new server failed", s->id);
goto fail;
}
bufferevent_settimeout(s->server_bufev, CONNECT_TIMEOUT, 0);
bufferevent_enable(s->server_bufev, EV_READ | EV_TIMEOUT);
return;
fail:
end_session(s);
}
