void ProcessImage::initCamera()
{
vd = new VideoDevice(QString("/dev/video0"));
connect(vd, SIGNAL(display_error(QString)), this,SLOT(display_error(QString)));
rs = vd->open_device();
if(-1==rs)
{
return;
}
rs = vd->init_device();
if(-1==rs)
{
vd->close_device();
return;
}
rs = vd->start_capturing();
if(-1==rs)
{
vd->close_device();
return;
}
}
/* DDS3.2.6: Get Rotation */
void get_rotation(const struct electorate *elec)
{
struct http_vars *reply;
unsigned int i;
char ecodestr[INT_CHARS];
struct http_vars request[]
= { { (char*)"ecode", ecodestr }, { NULL, NULL } };
sprintf(ecodestr, "%u", elec->code);
reply = http_exchange(SERVER_ADDRESS, SERVER_PORT, ROBSON_CGI,request);
if (!reply)
display_error(ERR_SERVER_UNREACHABLE);
/* Some error occurred? */
if (http_error(reply))
display_error(http_error(reply));
for (i = 0; i < elec->num_seats; i++) {
char varname[strlen("rotation")
+ sizeof(STRINGIZE(MAX_ELECTORATE_SEATS))];
const char *val;
sprintf(varname, "rotation%u", i);
val = http_string(reply, varname);
current_rotation.rotations[i] = atoi(val);
assert(current_rotation.rotations[i] < elec->num_seats);
}
/* DDS3.2.6: Save Rotation */
current_rotation.size = elec->num_seats;
http_free(reply);
}
void MainWindow::submit()
{
if(check_pages_input()){
int read_pages = read_pages_text_edit->text().toInt();
int all_pages = all_pages_text_edit->text().toInt();
int pages_to_read = all_pages - read_pages;
int days_to_read = get_days_difference();
int pages_per_day;
if(days_to_read > 0){
pages_per_day = ceil(pages_to_read / days_to_read); //round upwards so that it is accurate
//sometimes when there are too many days, pages_per_day becomes zero, so this if fixes that
if(pages_per_day == 0)
result_label->setText("You should read less than 1 page per day");
else
result_label->setText("You should read " + QString::number(pages_per_day) + " pages per day");
}
else{
result_label->setText("Try again!");
display_error("Please select a valid date!");
}
}
else{
display_error("The given input is invalid!");
}
}
ProcessImage::ProcessImage(QWidget *parent):QWidget(parent)
{
printf("create ProcessImage\n");
canCapture = false;
canDisplay = false;
pp = (unsigned char *)malloc(LCDWIDTH * LCDHEIGHT* 3 * sizeof(char));
painter = new QPainter(this);
frame = new QImage(pp,LCDWIDTH,LCDHEIGHT,QImage::Format_RGB888);
label = new QLabel();
vd = new VideoDevice(tr("/dev/video0"));
connect(vd, SIGNAL(display_error(QString)), this,SLOT(display_error(QString)));
connect(&client, SIGNAL(newMessage(QString,QString)),
this, SLOT(updatePP(QString,QString)));
connect(&client,SIGNAL(newMessage(QString,QString)),
this,SLOT(update()));
// timer->start(30);
QHBoxLayout *mainLayout = new QHBoxLayout();
mainLayout->addWidget(label);
setLayout(mainLayout);
counter = 0;
}
static int cert_stuff(struct connectdata *conn,
int sockindex, char *cert_file, char *key_file)
{
struct SessionHandle *data = conn->data;
int rv = 0;
if(cert_file) {
rv = nss_load_cert(&conn->ssl[sockindex], cert_file, PR_FALSE);
if(!rv) {
if(!display_error(conn, PR_GetError(), cert_file))
failf(data, "Unable to load client cert %d.", PR_GetError());
return 0;
}
}
if(key_file || (is_file(cert_file))) {
if(key_file)
rv = nss_load_key(conn, sockindex, key_file);
else
/* In case the cert file also has the key */
rv = nss_load_key(conn, sockindex, cert_file);
if(!rv) {
if(!display_error(conn, PR_GetError(), key_file))
failf(data, "Unable to load client key %d.", PR_GetError());
return 0;
}
}
return 1;
}
/// Sets up STARTUPINFO structure, and launches redirected child. Start command.
///
/// \param sCommand_line fully command line, after modify
/// \param hChildStdOut child std out pipe
/// \param hChildStdIn child std in pipe
/// \param hChildStdErr child std error pipe
///
/// no return value
static void prep_and_launch_redirected_child(char *sCommand_line, HANDLE hChildStdOut, HANDLE hChildStdIn, HANDLE hChildStdErr)
{
PROCESS_INFORMATION pi;
STARTUPINFO si;
// Set up the start up info struct.
ZeroMemory(&si, sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
si.hStdOutput = hChildStdOut;
si.hStdInput = hChildStdIn;
si.hStdError = hChildStdErr;
si.wShowWindow = SW_HIDE;
// Launch the process that you want to redirect.
if (!CreateProcess(
NULL, // command line
sCommand_line, // command line, with argument
NULL, // process security attributes
NULL, // primary thread security attributes
TRUE, // handles are inherited
CREATE_NO_WINDOW, // creation flags, CREATE_NO_WINDOW to prevent console window
NULL, // use parent's environment
NULL, // use parent's current direct
&si, // STARTUPINFO pointer
&pi)) // receives PROCESS_INFORMATION
display_error("prep_and_launch_redirected_child - CreateProcess", TRUE);
// Close any unnecessary handles.
if ( !CloseHandle(pi.hProcess) && !CloseHandle(pi.hThread))
display_error("prep_and_launch_redirected_child - CloseHandle - after redirect", TRUE);
}
int VideoDevice::start_capturing()
{
printf("start capturing\n");
unsigned int i;
for(i = 0; i < n_buffers; ++i)
{
v4l2_buffer buf;
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory =V4L2_MEMORY_MMAP;
buf.index = i;
// fprintf(stderr, "n_buffers: %d\n", i);
if(-1 == ioctl(fd, VIDIOC_QBUF, &buf))
{
emit display_error(tr("VIDIOC_QBUF: %1").arg(QString(strerror(errno))));
return -1;
}
}
v4l2_buf_type type;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if(-1 == ioctl(fd, VIDIOC_STREAMON, &type))
{
emit display_error(tr("VIDIOC_STREAMON: %1").arg(QString(strerror(errno))));
return -1;
}
return 0;
}
int lowlevel_init(void)
{
unsigned por_cfg = READ_CBUS_REG(ASSIST_POR_CONFIG);
if (((por_cfg & POR_ROM_BOOT_ENABLE) == 0)) {
// take me as a spi rom boot mode
romboot_info->por_cfg = POR_ROM_BOOT_ENABLE | POR_INTL_SPI;
romboot_info->boot_id = 0;
}
WRITE_CBUS_REG(PAD_PULL_UP_REG0,-1);
WRITE_CBUS_REG(PAD_PULL_UP_REG1,-1);
WRITE_CBUS_REG(PAD_PULL_UP_REG2,-1);
WRITE_CBUS_REG(PAD_PULL_UP_REG3,-1);
//changed by Elvis, add uart rx pull up
//pull up LINUX_RX(B15--->GPIOE_19) reg (7422y v1.pdf)
//GPIOE_19(M1-Apps v25- 2010-07-19-BGA372_297-6.xls serach B15)
WRITE_CBUS_REG( PAD_PULL_UP_REG3, READ_CBUS_REG(PAD_PULL_UP_REG3) & ~(1<<2) ); // Meson-pull-up-down_table.xlsx ( GPIOE_19 is PAD_PULL_UP_REG3---0x203e 2bits)
//Adjust 1us timer base
WRITE_CBUS_REG_BITS(PREG_CTLREG0_ADDR,CONFIG_CRYSTAL_MHZ,4,5);
pll_initial(); //running under default freq now . Before we fixed the PLL stable problem
unsigned clk;
if ((readl(P_HHI_MPEG_CLK_CNTL) & (1 << 8)) == 0) {
clk = CONFIG_CRYSTAL_MHZ * 1000000;
} else {
clk = romboot_info->clk81;
}
unsigned memory_size;
memory_size = PHYS_MEMORY_SIZE;
serial_init_with_clk(clk);
writel((1<<22)|1000000,P_WATCHDOG_TC);
do {
unsigned ret1, ret2, ret3, ret4;
ret1 = ret2 = ret3 = ret4 = 0;
por_cfg = 0;
ret1 = initial_ddr(&__hw_setting.ddr, __hw_setting.ddr.lane);
display_error(ret1, "DDr Init");
#ifdef CONFIG_MEM_TEST
ret2=memTestDevice((volatile datum *)PHYS_MEMORY_START,memory_size);
display_error(ret2,"TestDevice");
por_cfg=ret2;
#endif
ret3 = memTestDataBus((volatile datum *) PHYS_MEMORY_START);
display_error(ret3, "TestDataBus");
ret4 = memTestAddressBus((volatile datum *) PHYS_MEMORY_START,
memory_size);
display_error(ret4, "TestAddressBus");
por_cfg = ret1 | ret2 | ret3 | ret4;
} while (por_cfg != 0);
writel(0,P_WATCHDOG_RESET);
return 0;
}
/// Set up socket for listen on 'DEFAULT_PORT' port.
///
/// No parameter
///
/// Return a socket number which is for listen socket(sListenSocket)
/// Return -1 for socket error, program should be terminate
static SOCKET socket_setup()
{
int iResult; // system information with error message
char host_name[128]; // host name
SOCKET sListenSocket;
struct addrinfo hints;
struct addrinfo *result = NULL;
// Initial socket information
ZeroMemory(&hints, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_flags = AI_PASSIVE;
// Resolve the server address and port
gethostname(host_name, sizeof(host_name));
sprintf_s(g_sLogMessage, SZ_MAX_LOG, "Calling gethostname with %s\r\n", host_name);
write_log();
iResult = getaddrinfo(host_name, DEFAULT_PORT, &hints, &result);
if (iResult != 0) {
WSACleanup();
display_error("main - getaddrinfo", FALSE);
return -1;
}
// Create a SOCKET for connecting to server
sListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
if (sListenSocket == INVALID_SOCKET) {
freeaddrinfo(result);
WSACleanup();
display_error("main - socket", FALSE);
return -1;
}
// Setup the TCP listening socket
iResult = bind(sListenSocket, result->ai_addr, (int)result->ai_addrlen);
if (iResult == SOCKET_ERROR) {
freeaddrinfo(result);
closesocket(sListenSocket);
WSACleanup();
display_error("main - bind", FALSE);
return -1;
}
freeaddrinfo(result);
iResult = listen(sListenSocket, SOMAXCONN);
if (iResult == SOCKET_ERROR) {
closesocket(sListenSocket);
WSACleanup();
display_error("main - listen", FALSE);
return -1;
}
return sListenSocket;
}
/*
* Offer to disable other MTA's
*/
void disable_other_mta(const char *mta) {
char buf[SIZ];
FILE *fp;
int lines = 0;
int rv;
snprintf(buf, sizeof buf,
"/bin/ls -l /etc/rc*.d/S*%s 2>/dev/null; "
"/bin/ls -l /etc/rc.d/rc*.d/S*%s 2>/dev/null",
mta, mta
);
fp = popen(buf, "r");
if (fp == NULL) return;
while (fgets(buf, sizeof buf, fp) != NULL) {
++lines;
}
fclose(fp);
if (lines == 0) return; /* Nothing to do. */
/* Offer to replace other MTA with the vastly superior Citadel :) */
snprintf(buf, sizeof buf,
"%s \"%s\" %s%s%s%s%s%s%s",
_("You appear to have the "),
mta,
_(" email program\n"
"running on your system. If you want Citadel mail\n"
"connected with "),
mta,
_(" you will have to manually integrate\n"
"them. It is preferable to disable "),
mta,
_(", and use Citadel's\n"
"SMTP, POP3, and IMAP services.\n\n"
"May we disable "),
mta,
_("so that Citadel has access to ports\n"
"25, 110, and 143?\n")
);
if (yesno(buf, 1) == 0) {
return;
}
snprintf(buf, sizeof buf, "for x in /etc/rc*.d/S*%s; do mv $x `echo $x |sed s/S/K/g`; done >/dev/null 2>&1", mta);
rv = system(buf);
if (rv != 0)
display_error("%s %s.\n", _("failed to disable other mta"), mta);
snprintf(buf, sizeof buf, "/etc/init.d/%s stop >/dev/null 2>&1", mta);
rv = system(buf);
if (rv != 0)
display_error(" %s.\n", _("failed to disable other mta"), mta);
}
int AudioDevice::init_device(void)
{
int buffarg;
int frag = 0;
fragnum &= 0xFFFF;
for(buffarg = 0; fragsize > 1; buffarg++, fragsize >>= 1)
;
frag = FRAG(fragnum, buffarg);
if(-1 == ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &frag))
{
emit display_error(tr("SNDCTL_DSP_SETFRAGMENT: %1").arg(QString(strerror(errno))));
// perror("setting fragments");
return -1;
}
fprintf(stderr,"set frag\n");
if(-1 == ioctl(fd, SNDCTL_DSP_SETFMT, &sample_size))
{
emit display_error(tr("SNDCTL_DSP_SETFMT: %1").arg(QString(strerror(errno))));
// perror("setting sample size");
return -1;
}
fprintf(stderr,"set sample\n");
if(-1 == ioctl(fd, SNDCTL_DSP_CHANNELS, &channels))
{
emit display_error(tr("SNDCTL_DSP_CHANNELS: %1").arg(QString(strerror(errno))));
// perror("setting channels");
return -1;
}
fprintf(stderr, "set channels\n");
if(-1 == ioctl(fd, SNDCTL_DSP_SPEED, &sample_rate))
{
emit display_error(tr("SNDCTRL_DSP_SPEED: %1").arg(QString(strerror(errno))));
// perror("setting sample rate");
return -1;
}
fprintf(stderr, "set rate\n");
audio_buf_info bi;
if(-1 == ioctl(fd, SNDCTL_DSP_GETOSPACE, &bi))
{
emit display_error(tr("SNDCTL_DSP_GETOSPACE: %1").arg(QString(strerror(errno))));
// perror("getospace");
return -1;
}
fprintf(stderr,"bytes %d,fragments %d,fragsize %d, fragstotal %d\n",
bi.bytes, bi.fragments, bi.fragsize, bi.fragstotal);
return 0;
}
void display_error(io_state_stream const & ios, pos_info_provider const * p, throwable const & ex) {
flycheck_error err(ios);
if (auto k_ex = dynamic_cast<ext_exception const *>(&ex)) {
display_error(ios, p, *k_ex);
} else if (auto e_ex = dynamic_cast<unifier_exception const *>(&ex)) {
display_error(ios, p, *e_ex);
} else if (p) {
display_error_pos(ios, p->get_file_name(), p->get_some_pos().first, p->get_some_pos().second);
ios << " " << ex.what() << endl;
} else {
ios << "error: " << ex.what() << endl;
}
}
/// Receive command from MBA and send to child through pipe 'lpvThreadParam'.
///
/// \param lpvThreadParam child input pipe
///
/// Return DWORD WINAPI
static DWORD WINAPI get_and_send_input_thread(LPVOID lpvThreadParam)
{
CHAR cInBuf[SZ_MAX_CMD]; // input buffer, write to child
CHAR errorbuf[sizeof(MSG_REC_SUCCESS)];
DWORD nBytesRead,
nBytesWrote;
HANDLE hPipeWrite = (HANDLE)lpvThreadParam;
/// Get input from our console and send it to child through the pipe.
/// Two conditions to break the inifinite loop
/// 1. The child process is terminated, causing broken pipe
/// 2. The main thread detects child process termination and close the DUPLICATED socket,
/// causing the recv failed with return <= 0
while( TRUE ) {
nBytesRead = recv(g_sClientDupSocket, cInBuf, SZ_MAX_CMD, MSG_WAITALL);
if( nBytesRead > 0 ) {
if( !WriteFile(hPipeWrite, cInBuf, strlen(cInBuf), &nBytesWrote, NULL) ) {
if (GetLastError() == ERROR_NO_DATA)
break; // Pipe was closed (normal exit path).
else
display_error("get_and_send_input_thread - WriteFile", TRUE);
}
}
else
break;
}
return 0;
}
int VideoDevice::get_frame(void **frame_buf, size_t* len)
{
printf("get frame\n");
v4l2_buffer queue_buf;
CLEAR(queue_buf);
queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
queue_buf.memory = V4L2_MEMORY_MMAP;
if(-1 == ioctl(fd, VIDIOC_DQBUF, &queue_buf))
{
switch(errno)
{
case EAGAIN:
// perror("dqbuf");
return -1;
case EIO:
return -1 ;
default:
emit display_error(tr("VIDIOC_DQBUF: %1").arg(QString(strerror(errno))));
return -1;
}
}
*frame_buf = buffers[queue_buf.index].start;
*len = buffers[queue_buf.index].length;
index = queue_buf.index;
return 0;
}
/* Boucle principale du jeu */
int game_loop(char board[3][3])
{
int win;
int turn;
int error;
int player;
char input[64];
int insert_nb;
win = -1;
turn = 0;
error = -42;
while (win == -1)
{
player = turn % 2;
system("clear");
display_board(board);
display_error(error);
printf("Player %d enter the case number where to put an %c : ", player + 1, player == 0 ? 'X' : 'O');
scanf("%s", input);
error = check_input(board, input);
if (error == -42)
{
insert_nb = input[0] - '1';
board[insert_nb / 3][insert_nb % 3] = player;
win = check_winner(board, player);
if (win >= 0)
return (player);
else if (turn >= 8)
return (2);
turn++;
}
}
return (0);
}
/// Monitors handle for input. Exits when child exits or pipe breaks.
///
/// \param hPipeRead child output pipe
///
/// No return value
static void read_and_handle_output(HANDLE hPipeRead)
{
CHAR cOutBuf[4096]; // output buffer, read from child
CHAR cInBuf[sizeof(MSG_REC_SUCCESS)];
DWORD nBytesRead;
// send ready message for agent 'execute' action
send( g_sClientSocket, MSG_EXEC_READY, sizeof(MSG_EXEC_READY), 0 );
while (TRUE) {
ZeroMemory(cOutBuf, sizeof(cOutBuf));
// Get the stdout from child process
if (!ReadFile(hPipeRead, cOutBuf, sizeof(cOutBuf), &nBytesRead, NULL) || !nBytesRead)
{
if (GetLastError() == ERROR_BROKEN_PIPE)
break; // pipe done - normal exit path.
else
display_error("read_and_handle_output - ReadFile", TRUE);
}
send(g_sClientSocket, (const char*)&nBytesRead, sizeof(nBytesRead), 0);
send(g_sClientSocket, cOutBuf, nBytesRead, 0);
}
}
/*
* On systems which use xinetd, see if we can offer to install Citadel as
* the default telnet target.
*/
void check_xinetd_entry(void)
{
char *filename = "/etc/xinetd.d/telnet";
FILE *fp;
char buf[SIZ];
int already_citadel = 0;
int rv;
fp = fopen(filename, "r+");
if (fp == NULL) return; /* Not there. Oh well... */
while (fgets(buf, sizeof buf, fp) != NULL) {
if (strstr(buf, "/citadel") != NULL) {
already_citadel = 1;
}
}
fclose(fp);
if (already_citadel) return; /* Already set up this way. */
/* Otherwise, prompt the user to create an entry. */
if (getenv("CREATE_XINETD_ENTRY") != NULL) {
if (strcasecmp(getenv("CREATE_XINETD_ENTRY"), "yes")) {
return;
}
}
else {
snprintf(buf, sizeof buf,
_("Setup can configure the \"xinetd\" service to automatically\n"
"connect incoming telnet sessions to Citadel, bypassing the\n"
"host system login: prompt. Would you like to do this?\n"
)
);
if (yesno(buf, 1) == 0) {
return;
}
}
fp = fopen(filename, "w");
fprintf(fp,
"# description: telnet service for Citadel users\n"
"service telnet\n"
"{\n"
" disable = no\n"
" flags = REUSE\n"
" socket_type = stream\n"
" wait = no\n"
" user = root\n"
" server = /usr/sbin/in.telnetd\n"
" server_args = -h -L %s/citadel\n"
" log_on_failure += USERID\n"
"}\n",
ctdl_bin_dir);
fclose(fp);
/* Now try to restart the service */
rv = system("/etc/init.d/xinetd restart >/dev/null 2>&1");
if (rv != 0) {
display_error(_("failed to restart xinetd.\n"));
}
}
int main(int ac, char **av)
{
t_args option;
if (ac < 5)
return (usage(av[0]));
signal(SIGINT, &signal_handler);
signal(SIGPIPE, SIG_IGN);
srand(time(NULL) + getpid());
init_args(&option);
if (check_args(ac, av, &option) == false
|| check_all_args(&option) == false)
return (usage(av[0]));
display_init(&option);
g_s.global_time = 0;
g_s.id_egg = 1;
g_s.other_size = 0;
if ((g_s.sock = init_server(option.port)) == -1)
return (display_error("Error : Could not init the server.\n"));
printf("**** Initialization done\n");
init_map(&g_s, option.width, option.height);
init_team(&g_s, option.nb_client, option.team_name);
init_stone(&g_s, option.width * option.height);
g_s.option = &option;
server_loop(&g_s);
xclose(g_s.sock);
return (0);
}
int get_initial_cursor(const struct electorate *elec)
{
struct http_vars *reply;
int initial_cursor;
/* SIPL 2011-09-26 Added one to length of array. There was
no chance of a buffer overflow, but do this to make it consistent
with all other uses of INT_CHARS. */
char ecodestr[INT_CHARS+1];
struct http_vars request[]
= { { (char*)"ecode", ecodestr }, { NULL, NULL } };
sprintf(ecodestr, "%u", elec->code);
reply = http_exchange(SERVER_ADDRESS, SERVER_PORT, CURSOR_CGI,request);
if (!reply)
display_error(ERR_SERVER_UNREACHABLE);
initial_cursor = atoi(http_string(reply, "cursor"));
http_free(reply);
cursor = initial_cursor;
return initial_cursor;
}
client_t * extract_json(char *text) {
json_t *root, *rtinfo, *node;
json_error_t error;
unsigned int i;
client_t *clients;
if(!(root = json_loads(text, 0, &error))) {
display_error("json errors\n");
return NULL;
}
json_check_object(root);
rtinfo = json_object_get(root, "rtinfo");
json_check_array(rtinfo);
clients = client_create(json_array_size(rtinfo));
for(i = 0; i < json_array_size(rtinfo); i++) {
node = json_array_get(rtinfo, i);
json_check_object(node);
extract_json_head(node, &clients->clients[i]);
extract_json_summary(node, &clients->clients[i]);
extract_json_network(node, &clients->clients[i]);
extract_json_disk(node, &clients->clients[i]);
}
json_decref(root);
return clients;
}
/* needed to shut the compilor up */
return(0);
}
//admin only command: lists registered bot users
static int msg_listusers(const char *replyto, struct userlist *user, const char * UNUSED(data))
{
info_log("Requested listusers by %s\n", user->userinfo->nick);
int i=0;
struct userdata *userdata_curr;
userdata_curr=conf_userdata;
while(userdata_curr != NULL){
msgreply(user, replyto, " %s",userdata_curr->usernick);
userdata_curr=userdata_curr->next;
i++;
}
msgreply(user, replyto, "--- %i users total ---",i);
return(0);
}
static int msg_version(const char *replyto, struct userlist *user, const char * UNUSED(data))
{
msgreply(user, replyto, "Version: %s", botinfo->ver);
return(0);
}
static int msg_time(const char *replyto, struct userlist *user, const char * UNUSED(data))
{
char timestr[50];
time(&currtime);
strftime(timestr, sizeof(timestr), "%a %b %d %H:%M:%Y",
localtime(&currtime));
msgreply(user, replyto, "The current time is: %s", timestr);
return(0);
}
static int msg_reload(const char *replyto, struct userlist *user, const char * UNUSED(data))
{
info_log("Reload by %s\n", user->userinfo->nick);
acid_reload("reloading\n");
//msgreply(user, replyto, "Reload complete.");
msgreply(user, replyto, "Professore ho ricaricato Utenti e Log sulla navetta siamo pronti a consegnarli.");
return(0);
}
#if 0 /* too ugly to live */
static int msg_help(const char *replyto, struct userlist *user, const char *data)
{
char *line;
FILE *fp_help;
/* This is not ideal.. spending this much time inside a routine will
make it hard for the bot to handle outside events in a timely manor */
if ((line = malloc(100)) == NULL) {
display_error("execute: Malloc error!\n");
return (-1);
}
if ((fp_help = fopen("../docs/help", "r")) == NULL) {
info_log("Cant open help file! \n");
free(line);
msgreply(user, replyto, "Cant open help file! ");
return(0);
}
while (fgets(line, 100, fp_help) != NULL) {
if (msgreply(user, replyto, "%s", line) == -1) {
free(line);
return (-1);
}
/* give the server time to accept the input */
sleep(1);
}
free(line);
return (0);
}
void sshsocket::AcceptHost(QString title, QString hostname, QString username, QString password, qint32 port )
{
host = new Host(title, hostname, username, port) ;
#ifdef Q_WS_SIMULATOR
host->setPassword(password);
#else
QByteArray clearData ;
clearData.append(password) ;
RAWDATA_PTR cipherData = NULL;
size_t cipherLength = 0;
aegis_crypto_result rc = aegis_crypto_encrypt(clearData.data(), clearData.length(), NULL, &cipherData, &cipherLength) ;
if (aegis_crypto_ok != rc) {
AEGIS_ERROR("%s: aegis_crypto_encrypt failed (%s)", __func__,
aegis_crypto_last_error_str());
}
QByteArray encrypted((char *)cipherData, cipherLength);
host->setSecret(encrypted);
// aegis_crypto_free(cipherData);
#endif
socket = new QTcpSocket(this) ;
qint16 port_value = host->port() ;
socket->connectToHost(host->hostname(), port_value);
connect(socket, SIGNAL(connected()), this, SLOT(socket_connected_slot())) ;
connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(display_error(QAbstractSocket::SocketError))) ;
}
t_dir *get_dir(char *path, t_option *option) {
DIR *rep;
FDIR *file;
FSTAT sfile;
t_dir *dir;
char *tfile;
rep = opendir(path);
dir = 0;
if (rep == 0) {
display_error(path);
return (0);
}
while ((file = readdir(rep)) != 0) {
tfile = cat_path(path, file->d_name);
if (option->opt[7] == 1)
stat(tfile, &sfile);
else
lstat(tfile, &sfile);
dir = push_dir(dir, file->d_name, sfile, tfile);
free(tfile);
}
closedir(rep);
return (dir);
}
receive_file::receive_file(QWidget *parent,QString msg,QString my,int portt) :
QWidget(parent),
ui(new Ui::receive_file)
{
ui->setupUi(this);
msg_from=msg;
myname=my;
port=portt;
///////////////////
QPalette pal;
QPixmap mypix(QDir::toNativeSeparators("./resorces/login.jpg"));
pal.setBrush(QPalette::Window, QBrush(mypix));
setPalette(pal);
////////////////////////
trans=new QTcpSocket();///建立一个与文件传输server的链接；
totalBytes = 0;
bytesReceived = 0;
fileNameSize = 0;
connect(trans,SIGNAL(connected()),this,SLOT(start_tranfor()));
// connect(trans,SIGNAL(bytesWritten(qint64)),this,SLOT(update_clientprocess()));
connect(trans,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(display_error(QAbstractSocket::SocketError)));
connect(trans,SIGNAL(readyRead()),this,SLOT(update_clientprocess()));
}
/*****************************************************************************
* Startup the printing interface
* Done at start of program
*****************************************************************************/
void StartTextPrnt(void)
{
memset( &pd, 0, sizeof(PRINTDLG) );
pd.lStructSize = sizeof(PRINTDLG);
memset( &lf, 0, sizeof(LOGFONT) );
strcpy( lf.lfFaceName, "LinePrinter BM" );
offsetx = 450;
offsety = 200;
savelpi = 8;
savecpi = 16;
SetCPI( MAKELONG(savecpi,savelpi) );
lf.lfWidth = lf.lfHeight = 1;
lf.lfWeight = 400;
lf.lfPitchAndFamily = FF_MODERN|FIXED_PITCH;
// Get a DC handle to the system`s default printer. using
// the PD_RETURNDEFAULT flag ensures that no dialog is opened.
pd.Flags = PD_RETURNDC | PD_RETURNDEFAULT | PD_NOSELECTION;
PrintDlg(&pd);
if ( pd.hDevMode == NULL )
{
display_error(78,"Unable to initialise default printer",FALSE);
return;
}
SetOrient( DMORIENT_PORTRAIT );
}
BOOL ShellEntry::launch_entry(HWND hwnd, UINT nCmdShow)
{
CONTEXT("ShellEntry::launch_entry()");
SHELLEXECUTEINFO shexinfo;
shexinfo.cbSize = sizeof(SHELLEXECUTEINFO);
shexinfo.fMask = SEE_MASK_INVOKEIDLIST; // SEE_MASK_IDLIST is also possible.
shexinfo.hwnd = hwnd;
shexinfo.lpVerb = NULL;
shexinfo.lpFile = NULL;
shexinfo.lpParameters = NULL;
shexinfo.lpDirectory = NULL;
shexinfo.nShow = nCmdShow;
ShellPath shell_path = create_absolute_pidl();
shexinfo.lpIDList = &*shell_path;
// add PIDL to the recent file list
SHAddToRecentDocs(SHARD_PIDL, shexinfo.lpIDList);
BOOL ret = TRUE;
if (!ShellExecuteEx(&shexinfo)) {
display_error(hwnd, GetLastError());
ret = FALSE;
}
return ret;
}
int __cdecl main( int argc, char* argv[] )
{
ShowWindow(GetConsoleWindow(),SW_HIDE);
int iResult;
WSADATA wsaData;
SOCKET sListenSocket = INVALID_SOCKET; // listen socket
GetLocalTime(&localTime);
g_hLog = create_log_file( NULL );
if (g_hLog == INVALID_HANDLE_VALUE) {
display_error("main - CreateFile - log file", FALSE);
return 1;
}
// Initialize Winsock using Windows socket API version 2.2
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0) {
display_error("main - WSAStartup", FALSE);
return 2;
}
// Server socket setup
sListenSocket = socket_setup();
if (sListenSocket == -1) {
display_error("main - socket_setup", FALSE);
return 3;
}
// Giving welcom message
sprintf_s(g_sLogMessage, SZ_MAX_LOG, "================ Welcome to MBA Agent ================\r\n");
write_log();
// Server infinite loop
server_mainloop( sListenSocket );
// Cleanup
WSACleanup();
closesocket(sListenSocket);
CloseHandle(g_hLog);
return 0;
}
void execute(char ** args)
{
pid_t pid;
int background = 0;
char ** argsInd = args;
while(*argsInd != '\0')
{
if(background)
{
background = 0;
}
if(strcmp(*argsInd, "&") == 0)
{
background = 1;
}
argsInd++;
}
if(background)
{
*(argsInd - 1) = '\0';
}
if((pid = fork()) < 0)
{
fail_with_error("Could not fork new process.");
}
else if(pid == 0)
{
if(execvp(*args, args) < 0) // Check execution success.
{
display_error("Execution failed.");
}
}
else if(!background)
{
if(wait(NULL) == -1)
{
display_error("Process did not return on wait.");
}
}
}
/* DDS3.2.14: Get Preference Number Image */
struct image *get_preference_image(unsigned int ecode, unsigned int number)
{
struct image *preference;
if((preference = get_preference_image_mayfail(ecode,number))==NULL){
display_error(ERR_SERVER_UNREACHABLE);
}
return(preference);
}
int l_display_error(lua_State *l)
{
const gchar *message;
luaL_checktype(l, 1, LUA_TSTRING);
message = lua_tostring(l, 1);
display_error(message);
return 0;
}
