Exemple #1
0
/* 
 * Startup the server listener.
 */
int startup_server(void)
{
	int optval = 1;
	
	/* Initialize client_info list */
	llist_init(&list_start);
	
	/* Create socket */
	server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval) != 0)
	{
		logline(LOG_DEBUG, "Error calling setsockopt(): %s", strerror(errno));
		return -1;
	}

	/* Name the socket */
	server_address.sin_family = AF_INET;
	server_address.sin_addr.s_addr = inet_addr(params->ip);
	server_address.sin_port = htons(params->port);
	server_len = sizeof(server_address);
	if (bind(server_sockfd, (struct sockaddr *)&server_address, server_len) != 0)
	{
		logline(LOG_DEBUG, "Error calling bind(): %s", strerror(errno));
		return -2;
	}

	/* Create a connection queue and wait for incoming connections */
	if (listen(server_sockfd, 5) != 0)
	{
		logline(LOG_DEBUG, "Error calling listen(): %s", strerror(errno));
		return -3;
	}

	return 0;
}
Exemple #2
0
uint32_t __stdcall Client::handleSvc(void* param) {
    HINSTANCE hInst = 0;
    bool connected = false;
    Client * pclient = (Client *)param;
    while (WAIT_OBJECT_0 == WaitForSingleObject(pclient->m_hEventRequest, INFINITE)) {
        while(!pclient->m_reqList.empty()) {
            if (!connected && !pclient->connect()) {
                logline(LOG::LEVEL_ERROR, "connect server failed. retry.");
                ::Sleep(CLT_CONNECT_INTERVAL);
                continue;
            } else {
                connected = true;
                logline(LOG::LEVEL_INFO, "connect server success.");
            }

            request_t pReq = pclient->m_reqList.front();
            if(!pclient->sendReq(&pReq)) {
                connected = false;
                continue;
            }
            pclient->m_reqList.pop_front();
        }
    }
    return 0;
}
Exemple #3
0
void help()
{
    logline();
    log("Commands: hook / log <address>,  hook / log api <module> <function>");
    log("          unhook <address>");
    log("          call <address> <args>, call api <module> <function> <args>");
    log("          hooks,                 quit / q / exit");
    logline();
}
Exemple #4
0
/*
 * Checks the input file if it contains valid ip addresses.
 */
int check_input_file_ip(void)
{
    int error = 0;
    FILE *f;
    int ret = 0;
    regex_t regex_ip;
    char line[256];

    /* Compile regex pattern */
    if ((ret = regcomp(&regex_ip, "^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}$", REG_EXTENDED)) != 0)
    {
        return -1;
    }

    /* Check if every line in the input file is a valid host */
    f = fopen(params->inputfile, "r");
    if (f != NULL)
    {
        while ((fgets(line, 255, f) != NULL) && (error == 0))
        {
            chomp(line);
            ret = regexec(&regex_ip, line, 0, NULL, 0);
            if (ret == 0)
            {
                logline(LOG_DEBUG, "    Work item %s is valid", line);
            }
            else if (ret == REG_NOMATCH)
            {
                logline(LOG_DEBUG, "    Work item %s has an invalid format", line);
                error = 1;
            }
            else
            {
                logline(LOG_DEBUG, "    Work item %s has an unknown problem. Return code was: %d", line, ret);
                error = 1;
            }
        }

        regfree(&regex_ip);
        fclose(f);

        if (error == 1)
        {
            return -2;
        }
    }
    else
    {
        /* File could not be opened */
        return -3;
    }

    return 0;
}
Exemple #5
0
/* child will spin waiting to be killed by debugger or parent or someone */
void do_child(void)
{
    pid_t doublechild;
    int ret;
    setprogname("CHILD");

    logline("child pid %d. waiting for external termination...", getpid());

    usleep(500000);

    doublechild = fork();
    if (doublechild == 0) {
        exit(0);
    } else if (doublechild == -1) {
        err(1, "doublechild");
    } else {
        ret = waitpid(doublechild, NULL, 0);
        if (ret == -1)
            err(1, "waitpid(%d) by parent failed", doublechild);
    }

    while (1) {
        sleep(60);
    }
}
Exemple #6
0
/* Wait for at least one new reply. Return when at least
 * min_replies slaves have already replied, or when the
 * given absolute time is passed.
 * The replies are returned in gtp_replies[0..reply_count-1]
 * slave_lock is held on entry and on return. */
void
get_replies(double time_limit, int min_replies)
{
	for (;;) {
		if (reply_count > 0) {
			struct timespec ts;
			double sec;
			ts.tv_nsec = (int)(modf(time_limit, &sec)*1000000000.0);
			ts.tv_sec = (int)sec;
			pthread_cond_timedwait(&reply_cond, &slave_lock, &ts);
		} else {
			pthread_cond_wait(&reply_cond, &slave_lock);
		}
		if (reply_count == 0) continue;
		if (reply_count >= min_replies || reply_count >= active_slaves) return;
		if (time_now() >= time_limit) break;
	}
	if (DEBUGL(1)) {
		char buf[1024];
		snprintf(buf, sizeof(buf),
			 "get_replies timeout %.3f >= %.3f, replies %d < min %d, active %d\n",
			 time_now() - start_time, time_limit - start_time,
			 reply_count, min_replies, active_slaves);
		logline(NULL, "? ", buf);
	}
	assert(reply_count > 0);
}
Exemple #7
0
int main(int argc, char **argv) {
	char *ename = basename(argv[0]);

	uint8_t msg[PCKT_LEN];
	memset(msg, 0, sizeof msg);

	msg[0] = MODE_LOCK; // c**k blocked

	if(strcmp(ename, "lock") == 0) {
		msg[1] = LOCK_LOCKED;
	} else if(strcmp(ename, "unlock") == 0) {
		msg[1] = LOCK_UNLOCKED;
	} else {
		printf("have a nice day ;)\n");
		return 0;
	}	
	
	sendpkt(msg);

	time_t rightnow = time(NULL);
	struct tm *stamp = localtime(&rightnow);
	char timestamp[100]; // probably big enough...
	struct passwd *userentry = getpwuid(getuid());

	strftime(timestamp, sizeof timestamp, "%a %F %T", stamp);
	logline("%s := Door %s by %s\n", timestamp, msg[1] == LOCK_LOCKED ? "locked" : "unlocked", userentry->pw_name);
	
	return 0;
}
Exemple #8
0
void Debug::Log(const char * fmt, ...)
{
	char buffer[MAX_LINE_LENGTH];

	va_list args;
	va_start(args,fmt);
	int charsWritten = vsnprintf_s(buffer, MAX_LINE_LENGTH, _TRUNCATE, fmt, args);
	va_end(args);

	std::string logline(buffer);
	if(charsWritten == -1) logline += "...";
	int firstNewline = -1;
	while( (firstNewline = logline.find("\n")) != -1 )
	{
		logLines.back().append(logline.substr(0,firstNewline));
		logline = logline.substr(firstNewline + strlen("\n"));
		logLines.emplace_back();
	}
	logLines.back().append(logline);

	if(logFile)
	{
		FILE * f;
		_wfopen_s(&f, logFile, L"a");
		if(f)
		{
			fprintf_s(f, buffer);
			fclose(f);
		}
	}

//#if windows build
	OutputDebugStringA(buffer);
//#endif
}
Exemple #9
0
void	cmd_retr(t_ftpserv *ftpserv, t_client *client, char *args)
{
  int	pid;

  logline(ftpserv, 1, "user ^ retr ^.\n", client->username, args);
  if ((pid = fork()) == -1)
    {
      send_msg2client(client, "451 fork error. Please try again later.\r\n");
      return ;
    }
  if (pid == 0)
    {
      if (client->mode == MODE_ACTF)
	make_connect_socket(client);
      send_msg2client(client, "150 Opening data connection.\r\n");
      if (client->mode == MODE_PASV)
	passiv_connect(ftpserv, client);
      do_retr(ftpserv, client, args);
      shutdown(client->data_fd, SHUT_RDWR);
      close(client->data_fd);
      if (client->mode == MODE_PASV)
	close(client->data_servfd);
      send_msg2client(client, "226 Transfer complete.\r\n");
    }
}
Exemple #10
0
/* Get a free binary buffer, first invalidating it in the receive
 * queue if necessary. In practice all buffers should be used
 * before they are invalidated, if BUFFERS_PER_SLAVE is large enough.
 * slave_lock is held on both entry and exit of this function. */
static void *
get_free_buf(struct slave_state *sstate)
{
	int newest = (sstate->newest_buf + 1) & (BUFFERS_PER_SLAVE - 1);
	sstate->newest_buf = newest;
	void *buf = sstate->b[newest].buf;

	if (DEBUGVV(7)) {
		char b[1024];
		snprintf(b, sizeof(b),
			 "get free %d index %d buf=%p age %d qlength %d\n", newest,
			 sstate->b[newest].queue_index, buf, queue_age, queue_length);
		logline(&sstate->client, "? ", b);
	}

	int index = sstate->b[newest].queue_index;
	if (index < 0) return buf;

	/* Invalidate the buffer if the calling thread still owns its previous
	 * entry in the receive queue. The entry may have been overwritten by
	 * another thread, but only after a new move which invalidates the
	 * entire receive queue. */
	if (receive_queue[index] && receive_queue[index]->owner == sstate->thread_id) {
		receive_queue[index] = NULL;
	}
	sstate->b[newest].queue_index = -1;
	return buf;
}
Exemple #11
0
bool Client::init() {
    if (!Sock::startup()) {
        return false;
    }

    m_pCl = new Cl();
    if (m_pCl == NULL) {
        logline(LOG::LEVEL_ERROR, "create Cl failed.");
        return false;
    }

#ifdef _DEBUG
    m_pCl->attachDbgCon();
#endif

    //m_hWaitEvent = CreateEvent(NULL, FALSE, FALSE, CLT_EVENTNAME_WAIT2WORK);
    //if (m_hWaitEvent == INVALID_HANDLE_VALUE) {
    //    logline(LOG::LEVEL_ERROR, "create event failed.(error = %d)\n", GetLastError());
    //    return false;
    //}

    m_pthHandleUI = new Pth(handleUI);
    if (m_pthHandleUI == NULL) {
        return false;
    }
    m_pthHandleUI->startThread(this);

    m_pthHandleSvc = new Pth(handleSvc);
    if (m_pthHandleSvc == NULL) {
        return false;
    }
    m_pthHandleSvc->startThread(this);

    m_pFrame = new Frame();
    if (m_pFrame == NULL) {
        logline(LOG::LEVEL_ERROR, "create mail frame failed.");
        return false;
    }
    m_pFrame->Create(NULL, CLT_MAINFRAME_TITLE, UI_WNDSTYLE_FRAME, WS_EX_WINDOWEDGE);
    m_pFrame->SetIcon(IDI_ICON);
    m_pFrame->ShowWindow(true);

    logline(LOG::LEVEL_INFO, "handleUI thread id = %d", m_pthHandleUI->getTid());
    logline(LOG::LEVEL_INFO, "handleSvc thread id = %d", m_pthHandleSvc->getTid());

    return true;
}
Exemple #12
0
void sbbs_t::logentry(const char *code, const char *entry)
{
	char str[512];

	now=time(NULL);
	sprintf(str,"Node %2d  %s\r\n   %s",cfg.node_num,timestr(now),entry);
	logline(code,str);
}
Exemple #13
0
/* Get a reply to one gtp command. Return the gtp command id,
 * or -1 if error. reply must have at least CMDS_SIZE bytes.
 * The ascii reply ends with an empty line; if the first line
 * contains "@size", a binary reply of size bytes follows the
 * empty line. @size is not standard gtp, it is only used
 * internally by Pachi for the genmoves command; it must be the
 * last parameter on the line.
 * *bin_size is the maximum size upon entry, actual size on return.
 * slave_lock is not held on either entry or exit of this function. */
static int
get_reply(FILE *f, struct in_addr client, char *reply, void *bin_reply, int *bin_size)
{
	double start = time_now();

	int reply_id = -1;
	*reply = '\0';
	if (!fgets(reply, CMDS_SIZE, f)) return -1;

	/* Check for binary reply. */
	char *s = strchr(reply, '@');
	int size = 0;
	if (s) size = atoi(s+1);
	assert(size <= *bin_size);
	*bin_size = size;

	if (DEBUGV(s, 2))
		logline(&client, "<<", reply);
	if ((*reply == '=' || *reply == '?') && isdigit(reply[1]))
		reply_id = atoi(reply+1);

	/* Read the rest of the ascii reply */
	char *line = reply + strlen(reply);
	while (fgets(line, reply + CMDS_SIZE - line, f) && *line != '\n') {
		if (DEBUGL(3))
			logline(&client, "<<", line);
		line += strlen(line);
	}
	if (*line != '\n') return -1;

	/* Read the binary reply if any. */
	int len;
	while (size && (len = fread(bin_reply, 1, size, f)) > 0) {
		bin_reply = (char *)bin_reply + len;
		size -= len;
	}
	if (*bin_size && DEBUGVV(2)) {
		char buf[1024];
		snprintf(buf, sizeof(buf), "read reply %d+%d bytes in %.4fms\n",
			 (int)strlen(reply), *bin_size,
			 (time_now() - start)*1000);
		logline(&client, "= ", buf);
	}
	return size ? -1 : reply_id;
}
Exemple #14
0
/* Send the gtp command to_send and get a reply from the slave machine.
 * Write the reply in buf which must have at least CMDS_SIZE bytes.
 * If *bin_size > 0, send bin_buf after the gtp command.
 * Return any binary reply in bin_buf and set its size in bin_size.
 * bin_buf is private to the slave and need not be copied.
 * Return the gtp command id, or -1 if error.
 * slave_lock is held on both entry and exit of this function. */
static int
send_command(char *to_send, void *bin_buf, int *bin_size,
	     FILE *f, struct slave_state *sstate, char *buf)
{
	assert(to_send && gtp_cmd && bin_buf && bin_size);
	strncpy(buf, to_send, CMDS_SIZE);
	bool resend = to_send != gtp_cmd;

	pthread_mutex_unlock(&slave_lock);

	if (DEBUGL(1) && resend)
		logline(&sstate->client, "? ",
			to_send == gtp_cmds ? "resend all\n" : "partial resend\n");

	double start = time_now();
	fputs(buf, f);

	if (*bin_size)
		fwrite(bin_buf, 1, *bin_size, f);
	fflush(f);

	if (DEBUGV(strchr(buf, '@'), 2)) {
		double ms = (time_now() - start) * 1000.0;
		if (!DEBUGL(3)) {
			char *s = strchr(buf, '\n');
			if (s) s[1] = '\0';
		}
		logline(&sstate->client, ">>", buf);
		if (*bin_size) {
			char b[1024];
			snprintf(b, sizeof(b),
				 "sent cmd %d+%d bytes in %.4fms\n",
				 (int)strlen(buf), *bin_size, ms);
			logline(&sstate->client, "= ", b);
		}
	}

	/* Reuse the buffers for the reply. */
	*bin_size = sstate->max_buf_size;
	int reply_id = get_reply(f, sstate->client, buf, bin_buf, bin_size);

	pthread_mutex_lock(&slave_lock);
	return reply_id;
}
Exemple #15
0
int sbbs_t::bulkmailhdr(smb_t* smb, smbmsg_t* msg, uint usernum)
{
    char		str[256];
    int			i,j;
	ushort		nettype=NET_UNKNOWN;
    node_t		node;
	user_t		user;
	smbmsg_t	newmsg;

	user.number=usernum;
	if(getuserdat(&cfg, &user)!=0)
		return(0);

	if((i=smb_copymsgmem(NULL,&newmsg,msg))!=SMB_SUCCESS)
		return(i);

	SAFECOPY(str,user.alias);
	smb_hfield_str(&newmsg,RECIPIENT,str);

	if(cfg.sys_misc&SM_FWDTONET && user.misc&NETMAIL && user.netmail[0]) {
		bprintf(text[UserNetMail],user.netmail);
		smb_hfield_netaddr(&newmsg,RECIPIENTNETADDR,user.netmail,&nettype);
		smb_hfield_bin(&newmsg,RECIPIENTNETTYPE,nettype);
	} else {
		sprintf(str,"%u",usernum);
		smb_hfield_str(&newmsg,RECIPIENTEXT,str);
	}

	j=smb_addmsghdr(smb,&newmsg,SMB_SELFPACK);
	smb_freemsgmem(&newmsg);
	if(j!=SMB_SUCCESS)
		return(j);

	lncntr=0;
	bprintf(text[Emailing],user.alias,usernum);
	sprintf(str,"%s bulk-mailed %s #%d"
		,useron.alias,user.alias,usernum);
	logline("E+",str);
	useron.emails++;
	logon_emails++;
	useron.etoday++;
	for(i=1;i<=cfg.sys_nodes;i++) { /* Tell user, if online */
		getnodedat(i,&node,0);
		if(node.useron==usernum && !(node.misc&NODE_POFF)
			&& (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
			sprintf(str,text[EmailNodeMsg],cfg.node_num,useron.alias);
			putnmsg(&cfg,i,str);
			break; 
		} 
	}
	if(i>cfg.sys_nodes) {   /* User wasn't online, so leave short msg */
		sprintf(str,text[UserSentYouMail],useron.alias);
		putsmsg(&cfg,usernum,str); 
	}
	return(0);
}
Exemple #16
0
/*
 * Shuts down the server properly by freeing all allocated resources.
 */
void shutdown_server(int sig)
{
	list_entry *cur = NULL;

	if ((sig == SIGINT) || (sig == SIGTERM))
	{
		if (sig == SIGINT)
			logline(LOG_INFO, "Server shutdown requested per SIGINT. Performing cleanup ops now.");
		if (sig == SIGTERM)
			logline(LOG_INFO, "Server shutdown requested per SIGTERM. Performing cleanup ops now.");
		
		/* Close all socket connections immediately */
		logline(LOG_INFO, "Closing socket connections...");		
		
		/* Iterate through client list and shutdown sockets */
		cur = &list_start;
		while (cur != NULL)
		{
			/* Lock entry */
			pthread_mutex_lock(cur->mutex);
		
			/* Send message to client */
			if (cur->client_info != NULL)
			{
				close(cur->client_info->sockfd);
			}
		
			/* Unlock entry */
			pthread_mutex_unlock(cur->mutex);
		
			/* Load next index */
			cur = cur->next;
		}		
		
		/* Close listener connection */
		logline(LOG_INFO, "Shutting down listener...");
		close(server_sockfd);

		/* Exit process */		
		logline(LOG_INFO, "Exiting. Byebye.");
		exit(0);
	}
}
Exemple #17
0
int test_all_permutations(void)
{
    int p, w;
    bool has_failure = false;

    for (p = 0; p <= 5; p++) {
        for (w = 0; w <= 3; w++) {
            int testpid;
            int ret;

            testpid = fork();
            if (testpid == 0) {
                logline("-------------------------------------------------------");
                logline("*** Executing self-test: %s -p %d -w %d",
                        getprogname(), p, w);
                test((parent_exit_t)p,
                     (debugger_exit_t)w);
                _exit(1); /* never reached */
            } else if (testpid == -1) {
                err(1, "failed to fork test pid");
            } else {
                int stat_loc;

                ret = waitpid(testpid, &stat_loc, 0);
                if (ret == -1)
                    err(1, "waitpid(%d) by test harness failed", testpid);

                logline("test process: %s", print_exit(testpid, stat_loc));
                if (!WIFEXITED(stat_loc) || (0 != WEXITSTATUS(stat_loc))) {
                    logline("FAILED TEST");
                    has_failure = true;
                }
            }
        }
    }

    if (has_failure) {
        logline("test failures found");
        return 1;
    }

    return 0;
}
Exemple #18
0
/* Thread sending gtp commands to one slave machine, and
 * reading replies. If a slave machine dies, this thread waits
 * for a connection from another slave.
 * The large buffers are allocated only once we get a first
 * connection, to avoid wasting memory if max_slaves is too large.
 * We do not invalidate the received buffers if a slave disconnects;
 * they are still useful for other slaves. */
static void *
slave_thread(void *arg)
{
	struct slave_state sstate = default_sstate;
	sstate.thread_id = (long)arg;

	assert(sstate.slave_sock >= 0);
	char reply_buf[CMDS_SIZE];
	bool resend = false;

	for (;;) {
		/* Wait for a connection from any slave. */
		struct in_addr client;
		int conn = open_server_connection(sstate.slave_sock, &client);

		FILE *f = fdopen(conn, "r+");
		if (DEBUGL(2)) {
			snprintf(reply_buf, sizeof(reply_buf),
				 "new slave, id %d\n", sstate.thread_id);
			logline(&client, "= ", reply_buf);
		}
		if (!is_pachi_slave(f, &client)) continue;

		if (!resend) slave_state_alloc(&sstate);
		sstate.client = client;

		pthread_mutex_lock(&slave_lock);
		active_slaves++;
		slave_loop(f, reply_buf, &sstate, resend);

		assert(active_slaves > 0);
		active_slaves--;
		// Unblock main thread if it was waiting for this slave.
		pthread_cond_signal(&reply_cond);
		pthread_mutex_unlock(&slave_lock);

		resend = true;
		if (DEBUGL(2))
			logline(&client, "= ", "lost slave\n");
		fclose(f);
	}
}
Exemple #19
0
/* Clear the receive queue. The buffer pointers do not have to be cleared
 * here, this is done as each buffer is recycled.
 * slave_lock is held on both entry and exit of this function. */
void
clear_receive_queue(void)
{
	if (DEBUGL(3)) {
		char buf[1024];
		snprintf(buf, sizeof(buf), "clear queue, old length %d age %d\n",
			 queue_length, queue_age);
		logline(NULL, "? ", buf);
	}
	queue_length = 0;
	queue_age++;
}
Exemple #20
0
/*
 * Process a list of work items.
 */
void *proc_workitems(void *arg)
{
    int ret = 0;
    workitem *wi_list;

    /* Cast input param to thread_params struct */
    thread_params* t_params = (thread_params *)arg;

    wi_list = t_params->wi_list;

    logline(LOG_DEBUG, "    Thread %d: Input params: reverse = %d, server = %s", t_params->thread_id, t_params->reverse, t_params->server);

    while (wi_list)
    {
        logline(LOG_DEBUG, "    Thread %d: Processing workitem %s", t_params->thread_id, wi_list->wi);
        if (t_params->reverse)
        {
            ret = do_reverse_dns_lookup(t_params->server, wi_list->wi, &(t_params->result_list));
        }
        else
        {
            ret = do_forward_dns_lookup(t_params->server, wi_list->wi, &(t_params->result_list));
        }

        if (ret < 0)
        {
            if (ret == -2)
            {
                logline(LOG_ERROR, "    Thread %d: DNS server temporarily not available. Skipping %s", t_params->thread_id, wi_list->wi);
            }
            else
            {
                logline(LOG_ERROR, "    Thread %d: Error querying DNS server. Error code: %d", t_params->thread_id, ret);
                pthread_exit(&ret);
            }
        }

        wi_list = wi_list->next;
    }
}
Exemple #21
0
/*@null@*/
char * readline (const char *prompt){
	char * ret;

	static char * (*func)(const char*);
	FN(func,char *,"readline",(const char *));

	ret = (*func)(prompt);

	if(ret != NULL)
		logline(ret);

	return ret;
}
Exemple #22
0
bool sbbs_t::chksyspass()
{
	char	str[256],str2[256];

	if(online==ON_REMOTE && !(cfg.sys_misc&SM_R_SYSOP)) {
		logline(LOG_NOTICE,"S!","Remote sysop access disabled");
		return(false);
	}
	bputs(text[SystemPassword]);
	getstr(str,40,K_UPPER|K_NOECHO);
	CRLF;
	if(strcmp(cfg.sys_pass,str)) {
		if(cfg.sys_misc&SM_ECHO_PW) 
			SAFEPRINTF3(str2,"%s #%u System password attempt: '%s'"
				,useron.alias,useron.number,str);
		else
			SAFEPRINTF2(str2,"%s #%u System password verification failure"
				,useron.alias,useron.number);
		logline(LOG_NOTICE,"S!",str2);
		return(false); 
	}
	return(true);
}
Exemple #23
0
/*
 * Changes the nickname of an existing chat user.
 */
void change_nickname(char *oldnickname, char *newnickname)
{
	struct list_entry *list_entry = NULL;
	client_info *ci_new = NULL;
	int idx = 0;
	
	logline(LOG_DEBUG, "change_nickname(): oldnickname = %s, newnickname = %s", oldnickname, newnickname);
	
	/* Load client_info element */
	list_entry = llist_find_by_nickname(&list_start, oldnickname);
	
	/*Lock entry */
	pthread_mutex_lock(list_entry->mutex);
	
	logline(LOG_DEBUG, "change_nickname(): client_info found. client_info->nickname = %s", 
		list_entry->client_info->nickname);
	
	/* Update nickname */
	strcpy(list_entry->client_info->nickname, newnickname);
	
	/* Unlock entry */
	pthread_mutex_unlock(list_entry->mutex);
}
Exemple #24
0
/* Thread opening a connection on the given socket and copying input
 * from there to stderr. */
static void *
proxy_thread(void *arg)
{
	int proxy_sock = (long)arg;
	assert(proxy_sock >= 0);
	for (;;) {
		struct in_addr client;
		int conn = open_server_connection(proxy_sock, &client);
		FILE *f = fdopen(conn, "r");
		char buf[BSIZE];
		while (fgets(buf, BSIZE, f)) {
			logline(&client, "< ", buf);
		}
		fclose(f);
	}
}
Exemple #25
0
/* Minimimal check of slave identity. Close the file if error. */
static bool
is_pachi_slave(FILE *f, struct in_addr *client)
{
	char buf[1024];
	fputs("name\n", f);
	if (!fgets(buf, sizeof(buf), f)
	    || strncasecmp(buf, "= Pachi", 7)
	    || !fgets(buf, sizeof(buf), f)
	    || strcmp(buf, "\n")) {
		logline(client, "? ", "bad slave\n");
		fclose(f);
		sleep(1); // avoid busy loop if error
		return false;
	}
	return true;
}
Exemple #26
0
void sbbs_t::change_user(void)
{
	uint	i;
	char	str[256];
	char	tmp[128];

	if(!chksyspass())
		return;
	bputs(text[ChUserPrompt]);
	if(!getstr(str,LEN_ALIAS,K_UPPER))
		return;
	if((i=finduser(str))==0)
		return;
	if(online==ON_REMOTE) {
		getuserrec(&cfg,i,U_LEVEL,2,str);
		if(atoi(str)>logon_ml) {
			getuserrec(&cfg,i,U_PASS,8,tmp);
			bputs(text[ChUserPwPrompt]);
			console|=CON_R_ECHOX;
			getstr(str,8,K_UPPER);
			console&=~(CON_R_ECHOX|CON_L_ECHOX);
			if(strcmp(str,tmp))
				return;
		}
	}
	putmsgptrs();
	putuserrec(&cfg,useron.number,U_CURSUB,0
		,cfg.sub[usrsub[curgrp][cursub[curgrp]]]->code);
	putuserrec(&cfg,useron.number,U_CURDIR,0
		,cfg.dir[usrdir[curlib][curdir[curlib]]]->code);
	useron.number=i;
	getuserdat(&cfg,&useron);
	getnodedat(cfg.node_num,&thisnode,1);
	thisnode.useron=useron.number;
	putnodedat(cfg.node_num,&thisnode);
	getmsgptrs();
	if(REALSYSOP) sys_status&=~SS_TMPSYSOP;
	else sys_status|=SS_TMPSYSOP;
	sprintf(str,"Changed into %s #%u",useron.alias,useron.number);
	logline("S+",str);
}
Exemple #27
0
void ScriptLogger::Log(const char* fmt, char* args)
{
	char* argStart = args;

	if(logFile)
	{
		FILE *f;
		_wfopen_s(&f, logFile, L"a");
		if(f)
		{
			vfprintf_s(f, fmt, args);
			fclose(f);
		}
	}

	args = argStart;

	char buffer[MAX_LINE_LENGTH];
	int charsWritten = vsnprintf_s(buffer, MAX_LINE_LENGTH, _TRUNCATE, fmt, args);
	std::string logline(buffer);
	if(charsWritten == -1) logline += "...";

	int firstNewline = -1;
	while((firstNewline = logline.find("\n")) != -1)
	{
		logLines[currentLine].append(logline.substr(0, firstNewline));
		logline = logline.substr(firstNewline + strlen("\n"));
		currentLine = (currentLine + 1 < numLines ? currentLine + 1 : 0);
		logLines[currentLine].clear();
	}
	logLines[currentLine].append(logline.c_str());

	args = argStart;

	vprintf(fmt, args);

	args = argStart;
}
Exemple #28
0
/* Insert a buffer in the receive queue. It should be the most
 * recent buffer allocated by the calling thread.
 * slave_lock is held on both entry and exit of this function. */
static void
insert_buf(struct slave_state *sstate, void *buf, int size)
{
	assert(queue_length < queue_max_length);

	int newest = sstate->newest_buf;
	assert(buf == sstate->b[newest].buf);

	/* Update the buffer if necessary before making it
	 * available to other threads. */
	if (sstate->insert_hook) sstate->insert_hook(buf, size);

	if (DEBUGVV(7)) {
		char b[1024];
		snprintf(b, sizeof(b),
			 "insert newest %d age %d rq[%d]->%p owner %d\n",
			 newest, queue_age, queue_length, buf, sstate->thread_id);
			logline(&sstate->client, "? ", b);
	}
	receive_queue[queue_length] = &sstate->b[newest];
	receive_queue[queue_length]->size = size;
	receive_queue[queue_length]->queue_index = queue_length;
	queue_length++;
}
Exemple #29
0
char sbbs_t::getkey(long mode)
{
	char	ch,coldkey,c=0,spin=sbbs_random(5);
	time_t	last_telnet_cmd=0;

	if(!online || !input_thread_running) {
		YIELD();	// just in case someone is looping on getkey() when they shouldn't
		return(0);
	}
	sys_status&=~SS_ABORT;
	if((sys_status&SS_USERON || action==NODE_DFLT) && !(mode&(K_GETSTR|K_NOSPIN)))
		mode|=(useron.misc&SPIN);
	lncntr=0;
	timeout=time(NULL);
	if(mode&K_SPIN)
		outchar(' ');

	do {
		if(sys_status&SS_ABORT) {
			if(mode&K_SPIN) /* back space once if on spinning cursor */
				backspace();
			return(0); 
		}

		if(mode&K_SPIN) {
			if(useron.misc&NO_EXASCII) {
				switch(c++) {
					case 0:
						outchar(BS);
						outchar('|');
						break;
					case 1:
						outchar(BS);
						outchar('/');
						break;
					case 2:
						outchar(BS);
						outchar('-');
						break;
					case 3:
						outchar(BS);
						outchar('\\');
						c=0;
						break;
				}
			} else {
				switch(spin) {
					case 0:
						switch(c++) {
							case 0:
								outchar(BS);
								outchar('³');
								break;
							case 1:
								outchar(BS);
								outchar('/');
								break;
							case 2:
								outchar(BS);
								outchar('Ä');
								break;
							case 3:
								outchar(BS);
								outchar('\\');
								c=0;
								break;
						}
						break;
					case 1:
						switch(c++) {
							case 0:
								outchar(BS);
								outchar('°');
								break;
							case 1:
								outchar(BS);
								outchar('±');
								break;
							case 2:
								outchar(BS);
								outchar('²');
								break;
							case 3:
								outchar(BS);
								outchar('Û');
								break;
							case 4:
								outchar(BS);
								outchar('²');
								break;
							case 5:
								outchar(BS);
								outchar('±');
								c=0;
								break;
						}
						break;
					case 2:
						switch(c++) {
							case 0:
								outchar(BS);
								outchar('-');
								break;
							case 1:
								outchar(BS);
								outchar('=');
								break;
							case 2:
								outchar(BS);
								outchar('ð');
								break;
							case 3:
								outchar(BS);
								outchar('=');
								c=0;
								break;
						}
						break;
					case 3:
						switch(c++) {
							case 0:
								outchar(BS);
								outchar('Ú');
								break;
							case 1:
								outchar(BS);
								outchar('À');
								break;
							case 2:
								outchar(BS);
								outchar('Ù');
								break;
							case 3:
								outchar(BS);
								outchar('¿');
								c=0;
								break;
						}
						break;
					case 4:
						switch(c++) {
							case 0:
								outchar(BS);
								outchar('Ü');
								break;
							case 1:
								outchar(BS);
								outchar('Þ');
								break;
							case 2:
								outchar(BS);
								outchar('ß');
								break;
							case 3:
								outchar(BS);
								outchar('Ý');
								c=0;
								break;
						}
						break; 
				}
			}
		}
		ch=inkey(mode,mode&K_SPIN ? 250:1000);
		if(sys_status&SS_ABORT)
			return(0);
		now=time(NULL);
		if(ch) {
			if(mode&K_NUMBER && isprint(ch) && !isdigit(ch))
				continue;
			if(mode&K_ALPHA && isprint(ch) && !isalpha(ch))
				continue;
			if(mode&K_NOEXASC && ch&0x80)
				continue;
			if(mode&K_SPIN)
				backspace();
			if(mode&K_COLD && ch>' ' && useron.misc&COLDKEYS) {
				if(mode&K_UPPER)
					outchar(toupper(ch));
				else
					outchar(ch);
				while((coldkey=inkey(mode,1000))==0 && online && !(sys_status&SS_ABORT))
					;
				backspace();
				if(coldkey==BS || coldkey==DEL)
					continue;
				if(coldkey>' ')
					ungetkey(coldkey); 
			}
			if(mode&K_UPPER)
				return(toupper(ch));
			return(ch); 
		}
		if(sys_status&SS_USERON && !(sys_status&SS_LCHAT)) gettimeleft();
		else if(online && now-answertime>SEC_LOGON && !(sys_status&SS_LCHAT)) {
			console&=~(CON_R_ECHOX|CON_L_ECHOX);
			console|=(CON_R_ECHO|CON_L_ECHO);
			bputs(text[TakenTooLongToLogon]);
			hangup(); 
		}
		if(sys_status&SS_USERON && online && (timeleft/60)<(5-timeleft_warn)
			&& !SYSOP && !(sys_status&SS_LCHAT)) {
			timeleft_warn=5-(timeleft/60);
			SAVELINE;
			attr(LIGHTGRAY);
			bprintf(text[OnlyXminutesLeft]
				,((ushort)timeleft/60)+1,(timeleft/60) ? "s" : nulstr);
			RESTORELINE; 
		}

		if(!(startup->options&BBS_OPT_NO_TELNET_GA)
			&& now!=last_telnet_cmd && now-timeout>=60 && !((now-timeout)%60)) {
			// Let's make sure the socket is up
			// Sending will trigger a socket d/c detection
			send_telnet_cmd(TELNET_GA,0);
			last_telnet_cmd=now;
		}
			
		if(online==ON_REMOTE && !(console&CON_NO_INACT)
			&& now-timeout>=cfg.sec_warn) { 					/* warning */
			if(sys_status&SS_USERON && cfg.sec_warn!=cfg.sec_hangup) {
				SAVELINE;
				bputs(text[AreYouThere]); 
			}
			else
				bputs("\7\7");
			while(!inkey(K_NONE,100) && online && now-timeout>=cfg.sec_warn) {
				now=time(NULL);
				if(now-timeout>=cfg.sec_hangup) {
					if(online==ON_REMOTE) {
						console|=CON_R_ECHO;
						console&=~CON_R_ECHOX; 
					}
					bputs(text[CallBackWhenYoureThere]);
					logline(nulstr,"Inactive");
					hangup();
					return(0); 
				}
			}
			if(sys_status&SS_USERON && cfg.sec_warn!=cfg.sec_hangup) {
				bputs("\r\1n\1>");
				RESTORELINE; 
			}
			timeout=now; 
		}

	} while(online);

	return(0);
}
Exemple #30
-1
// writeLog()
//
//  Write data to the HTTP log server
//  Log messages:
//    1 : logged in
//    2 : logged out
//    3 : pedal dn
//    4 : pedal up
//    5 : software terminating normally
//    6 : software terminating abnormally
//    7 : Software error (i.e. Omni connection lost)
//
void ServerNForm::writeLog(QString log_message, QString log_level)
{
	infoText->append( "Wrote to log: " + log_message +"." );

	QTime t; t.start();
	QDate d = QDate::currentDate();
	QString surgeon_name(m_surgeon_name);
	QString time=t.toString("hh:mm:ss.zzz");
	QString date;
	date=d.toString("dd-MMMM-yyyy");
	QString logline(date + "\t"
		 + time + "\t" 
		 + surgeon_name + "\t" 
		 + log_level + "\t" 
		 + log_message );

	QUrl::encode(surgeon_name);
	QUrl::encode(log_message);
	QUrl::encode(time);

	// format log message: time, user, log_level, message
	QString B( "timestamp=" + time + 
		"&user="******"&log_level=" + log_level +
		"&log_message=" + log_message );

	QHttpRequestHeader header("POST", "/log_server/index.php");
	header.setValue("Host", "brl.ee.washington.edu");
	header.setContentType("application/x-www-form-urlencoded");
	http.setHost("brl.ee.washington.edu");
	http.request(header, B.utf8());

	// TODO:  Also write to a text file here
	QStringList lines;
	lines += logline.toLatin1(); 
	QFile file( "logfile.txt" );
    if ( file.open( IO_WriteOnly | IO_Append ) ) {
        QTextStream stream( &file );
        for ( QStringList::Iterator it = lines.begin(); it != lines.end(); ++it )
			stream << *it << "\n";
		file.close();
    }

}