int main()
{
struct sockaddr_in peeraddr;
socklen_t addrlen;
pid_t pid;
sockfd = network_init();
if (-1 == pipe(pipefd))
error_exit("pipe");
mesgbuff = (mesgpack_st *)malloc(sizeof(mesgpack_st));
userlist = (linknode_st *)malloc(sizeof(linknode_st));
userlist->next = NULL;
if (-1 == (pid = fork()))
error_exit("fork");
/* ============== child, process client message ===============*/
if (0 == pid) {
close(pipefd[1]);
signal(SIGUSR1, sigusr1_handler);
while (1) {
if( 0 >= recvfrom(sockfd, mesgbuff, sizeof(mesgpack_st),0,
(struct sockaddr *)&peeraddr, &addrlen))
perror("child:recvfrom");
printf("[%d]%s:%d\n", addrlen,
inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
switch (mesgbuff->type) {
case CMD_CHAT:
broadcast(sockfd, userlist, mesgbuff);
break;
case CMD_LOGIN:
user_login(sockfd, userlist, (struct sockaddr *)&peeraddr, mesgbuff);
break;
case CMD_LOGOUT:
user_logout(sockfd, userlist, (struct sockaddr *)&peeraddr, mesgbuff);
break;
default:
break;
}
}
} else {
/* ================ father process local data ============= */
close(pipefd[0]);
strcpy(mesgbuff->user, "system");
setbuf(stdout, NULL);
while (1) {
printf(">");
fgets(mesgbuff->data, DATA_BUFF_LEN, stdin);
write(pipefd[1], mesgbuff->data, DATA_BUFF_LEN);
kill(pid, SIGUSR1);
}
}
return 0;
}
FormosaExit()
{
int fd = getdtablesize();
while (fd)
(void) close(--fd);
if (ifPass)
user_logout(cutmp, &curuser);
ReleaseSocket();
exit(0);
}
void
TimeOut(int s)
{
if (ifPass)
{
#if 1
if (uinfo.active < 1 || uinfo.active > MAXACTIVE)
csbbslog("ERR", "%s TimeOut user_logout: active[%d]", uinfo.userid, uinfo.active);
#endif
user_logout(cutmp, &curuser);
}
ReleaseSocket();
exit(1);
}
void server_parse_input(char * message){
//if query is empty... do nothing
if(strlen(message)==0)return;
//if query is type 1 - login user
if(message[0]=='1'){
//skip first 2 characters "1|"
message+=2;
//alocate memory for user
user_t * user = malloc(sizeof(user_t));
//copy username
char * separator = strchr(message,'|');
separator[0]='\0';
user->username = malloc((strlen(message)+1)*sizeof(char));
strcpy(user->username, message);
//erase copied characters from message
message = separator+1;
//copy password
user->password = malloc((strlen(message)+1)*sizeof(char));
strcpy(user->password, message);
//authentificate used
if(user_auth(user)){
//and log in
if(!user_login(user)){
message_send(user,"Server is full !!!\n");
free(user->username);
free(user->password);
free(user);
}
}
//wrong credentials
else{
message_send(user,"Login incorrect\n");
free(user->username);
free(user->password);
free(user);
}
}
//if query is of type 2 - send online users
else if(message[0]=='2'){
//print to server console
printf("Sending online users\n");
//skip first 2 characters - 2|
message+=2;
//call function with given name of named pipe
print_online(message);
}
//query is of type 3 - send message
//query format is 3|from|to|message
else if(message[0]=='3'){
//skip first 2 characters - 3|
message+=2;
//copy "from"
char * separator = strchr(message,'|');
separator[0]='\0';
char * from = malloc((strlen(message)+1)*sizeof(char));
strcpy(from, message);
//erase copyied characters
message = separator+1;
//copy "to"
separator = strchr(message,'|');
separator[0]='\0';
char * to = malloc((strlen(message)+1)*sizeof(char));
strcpy(to, message);
//erase copied characters
message = separator+1;
//find user "to"
user_t * user=NULL;
for(int i=0; i<SERVER_CAPACITY; i++){
if(users_logged[i] && !strcmp(users_logged[i]->username,to)){
user=users_logged[i];
}
}
//if we have found user "to"
if(user){
//compose message
char tmp[BUFFER_SIZE];
tmp[0]='\0';
strcat(tmp,from);
strcat(tmp," -> ");
strcat(tmp,message);
strcat(tmp,"\n");
//send message to user "to"
message_send(user,tmp);
//print message to server console
printf("User %s sent a message to %s\n",from, to);
}
//free used memory
free(from);
free(to);
}
//query is of type 4 - logout user
else if(message[0]=='4'){
//erase first 2 characters - 4|
message+=2;
//logout user
user_logout(message);
}
}
// INT 80h Handler, kernel entry.
void int_80() {
if(krn) {
return;
}
krn++;
int systemCall = kernel_buffer[0];
int fd = kernel_buffer[1];
int buffer = kernel_buffer[2];
int count = kernel_buffer[3];
int i, j;
Process * current;
Process * p;
int inode;
int _fd;
// Yeah, wanna know why we don't access an array directly? ... Because of big bugs we might have.
switch(systemCall) {
case READY:
kernel_buffer[KERNEL_RETURN] = kernel_ready();
break;
case WRITE:
current = getp();
kernel_buffer[KERNEL_RETURN] = fd_write(current->file_descriptors[fd],(char *)buffer,count);
break;
case READ:
current = getp();
kernel_buffer[KERNEL_RETURN] = fd_read(current->file_descriptors[fd],(char *)buffer,count);
break;
case MKFIFO:
_fd = process_getfreefd();
fd = fd_open(_FD_FIFO, (void *)kernel_buffer[1],kernel_buffer[2]);
if(_fd != -1 && fd != -1) {
getp()->file_descriptors[_fd] = fd;
kernel_buffer[KERNEL_RETURN] = _fd;
}
else {
kernel_buffer[KERNEL_RETURN] = -1;
}
break;
case OPEN:
_fd = process_getfreefd();
fd = fd_open(_FD_FILE, (void *) kernel_buffer[1], kernel_buffer[2]);
if(_fd != -1 && fd >= 0)
{
getp()->file_descriptors[_fd] = fd;
kernel_buffer[KERNEL_RETURN] = _fd;
}
else {
kernel_buffer[KERNEL_RETURN] = fd;
}
break;
case CLOSE:
kernel_buffer[KERNEL_RETURN] = fd_close(getp()->file_descriptors[fd]);
break;
case PCREATE:
kernel_buffer[KERNEL_RETURN] = sched_pcreate(kernel_buffer[1],kernel_buffer[2],kernel_buffer[3]);
break;
case PRUN:
kernel_buffer[KERNEL_RETURN] = sched_prun(kernel_buffer[1]);
break;
case PDUP2:
kernel_buffer[KERNEL_RETURN] = sched_pdup2(kernel_buffer[1],kernel_buffer[2],kernel_buffer[3]);
break;
case GETPID:
kernel_buffer[KERNEL_RETURN] = sched_getpid();
break;
case WAITPID:
kernel_buffer[KERNEL_RETURN] = sched_waitpid(kernel_buffer[1]);
break;
case PTICKS:
kernel_buffer[KERNEL_RETURN] = (int) storage_index();
break;
case PNAME:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) NULL;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->name;
}
break;
case PSTATUS:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->state;
}
break;
case PPRIORITY:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->priority;
}
break;
case PGID:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->gid;
}
break;
case PGETPID_AT:
p = process_getbypindex(kernel_buffer[1]);
if (p->state != -1) {
kernel_buffer[KERNEL_RETURN] = (int) p->pid;
} else {
kernel_buffer[KERNEL_RETURN] = -1;
}
break;
case KILL:
kernel_buffer[KERNEL_RETURN - 1] = kernel_buffer[1];
kernel_buffer[KERNEL_RETURN - 2] = kernel_buffer[2];
break;
case PSETP:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL) {
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
if(kernel_buffer[2] <= 4 && kernel_buffer[2] >= 0) {
p->priority = kernel_buffer[2];
}
kernel_buffer[KERNEL_RETURN] = (int) p->gid;
}
break;
case SETSCHED:
sched_set_mode(kernel_buffer[1]);
break;
case PWD:
kernel_buffer[KERNEL_RETURN] = (int) fs_pwd();
break;
case CD:
kernel_buffer[KERNEL_RETURN] = (int) fs_cd(kernel_buffer[1]);
break;
case FINFO:
fs_finfo(kernel_buffer[1], kernel_buffer[2]);
break;
case MOUNT:
fs_init();
break;
case MKDIR:
kernel_buffer[KERNEL_RETURN] = (int) fs_mkdir(kernel_buffer[1],current_ttyc()->pwd);
break;
case RM:
inode = fs_indir(kernel_buffer[1],current_ttyc()->pwd);
if (inode) {
kernel_buffer[KERNEL_RETURN] = (int) fs_rm(inode,0);
} else {
kernel_buffer[KERNEL_RETURN] = ERR_NO_EXIST;
}
break;
case GETUID:
if(kernel_buffer[1] == 0)
{
kernel_buffer[KERNEL_RETURN] = (int) current_ttyc()->uid;
} else {
kernel_buffer[KERNEL_RETURN] = (int) user_exists(kernel_buffer[1]);
}
break;
case GETGID:
if(kernel_buffer[1] == 0)
{
kernel_buffer[KERNEL_RETURN] = (int) user_gid(current_ttyc()->uid);
} else {
kernel_buffer[KERNEL_RETURN] = (int) user_gid(kernel_buffer[1]);
}
break;
case MAKEUSER:
kernel_buffer[KERNEL_RETURN] = user_create(kernel_buffer[1],
kernel_buffer[2], user_gid(current_ttyc()->uid));
break;
case SETGID:
kernel_buffer[KERNEL_RETURN] = user_setgid(kernel_buffer[1],
kernel_buffer[2]);
break;
case UDELETE:
kernel_buffer[KERNEL_RETURN] = user_delete(kernel_buffer[1]);
break;
case UEXISTS:
kernel_buffer[KERNEL_RETURN] = user_exists(kernel_buffer[1]);
break;
case ULOGIN:
kernel_buffer[KERNEL_RETURN] = user_login(kernel_buffer[1],
kernel_buffer[2]);
break;
case ULOGOUT:
kernel_buffer[KERNEL_RETURN] = user_logout();
break;
case CHOWN:
kernel_buffer[KERNEL_RETURN] = fs_chown(kernel_buffer[1],
kernel_buffer[2]);
break;
case CHMOD:
kernel_buffer[KERNEL_RETURN] = fs_chmod(kernel_buffer[1],
kernel_buffer[2]);
break;
case GETOWN:
kernel_buffer[KERNEL_RETURN] = fs_getown(kernel_buffer[1]);
break;
case GETMOD:
kernel_buffer[KERNEL_RETURN] = fs_getmod(kernel_buffer[1]);
break;
case CP:
kernel_buffer[KERNEL_RETURN] = fs_cp(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd, current_ttyc()->pwd);
break;
case MV:
kernel_buffer[KERNEL_RETURN] = fs_mv(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd);
break;
case LINK:
kernel_buffer[KERNEL_RETURN] = fs_open_link(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd);
break;
case FSSTAT:
kernel_buffer[KERNEL_RETURN] = fs_stat(kernel_buffer[1]);
break;
case SLEEP:
kernel_buffer[KERNEL_RETURN] = scheduler_sleep(kernel_buffer[1]);
break;
default:
break;
}
krn--;
}
void work::run()
{
struct epoll_event ev,events[CLIENTCOUNT];
setnonblocking(listen_st);
int epfd = epoll_create(CLIENTCOUNT);
ev.data.fd = listen_st;
ev.events = EPOLLIN | EPOLLERR | EPOLLHUP;
epoll_ctl(epfd,EPOLL_CTL_ADD,listen_st,&ev);
int st = 0;
while(1)
{
int nfds = epoll_wait(epfd,events,CLIENTCOUNT,-1);
if(nfds == -1)
{
printf("epoll_wait failed %s\n",strerror(errno));
break;
}
for(int i=0;i < nfds ;i++)
{
if(events[i].data.fd < 0)
continue;
if(events[i].data.fd == listen_st)
{
st = socket_accept();
if( st >= 0)
{
setnonblocking(st);
ev.data.fd = st;
ev.events = EPOLLIN | EPOLLERR | EPOLLHUP;
epoll_ctl(epfd,EPOLL_CTL_ADD,st,&ev);
continue;
}
}
if(events[i].events & EPOLLIN)
{
st = events[i].data.fd;
if(socket_recv(st) <= 0)
{
user_logout(st);
events[i].data.fd = -1;
}
}
if(events[i].events & EPOLLERR)
{
st = events[i].data.fd;
user_logout(st);
events[i].data.fd = -1;
}
if(events[i].events & EPOLLHUP)
{
st = events[i].data.fd;
user_logout(st);
events[i].data.fd = -1;
}
}
}
}
int main(int argc, char **argv, char **envp)
{
CGI *cgi = NULL;
NEOERR *err;
mdb_conn *conn = NULL;
/* skey, user, pass, return jsoncallback*/
char *s, *u, *r, *jcbk;
//sleep(20);
mtc_init("logout");
mconfig_parse_file(SITE_CONFIG, &g_cfg);
mutil_wrap_fcgi(argc, argv, envp);
if (mdb_init(&conn, DB_DSN) != MDB_ERR_NONE) {
mtc_err("init db error %s", mdb_get_errmsg(conn));
printf("Content-Type: text/html; charset=UTF-8\r\n\r\n");
printf("{errcode: %d}", SAM_ERR_INIT);
return 1;
}
#ifndef DROP_FCGI
while (FCGI_Accept() >= 0) {
#endif
/*
* cgi init
*/
err = cgi_init(&cgi, NULL);
if (err != STATUS_OK) {
mtc_err("init cgi error");
printf("Content-Type: text/html; charset=UTF-8\r\n\r\n");
printf("{errcode: %d}", SAM_ERR_INIT);
goto opfinish;
}
err = cgi_parse(cgi);
if (err != STATUS_OK) {
mtc_err("parse cgi error");
hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_PARSE);
goto opfinish;
}
u = hdf_get_value(cgi->hdf, PRE_COOKIE".samuser", NULL);
s = hdf_get_value(cgi->hdf, PRE_COOKIE".samkey", NULL);
if (s && u) {
if (user_has_login(conn, u, s)) {
user_logout(conn, u);
cgi_cookie_clear(cgi, "samuser", SITE_DOMAIN, NULL);
cgi_cookie_clear(cgi, "samkey", SITE_DOMAIN, NULL);
hdf_set_value(cgi->hdf, PRE_OUTPUT".success", "1");
goto opfinish;
}
}
hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_NOTLOGIN);
opfinish:
if (cgi) {
r = hdf_get_value(cgi->hdf, PRE_QUERY".r", NULL);
if (r) {
cgi_redirect(cgi, r);
} else {
jcbk = hdf_get_value(cgi->hdf, PRE_QUERY".jsoncallback", NULL);
if (jcbk != NULL) {
mjson_execute_hdf(cgi->hdf, jcbk, 0);
} else {
mjson_output_hdf(cgi->hdf, 0);
}
}
#ifdef DEBUG_HDF
hdf_write_file(cgi->hdf, HF_LOG_PATH"hdf.logout");
#endif
cgi_destroy(&cgi);
}
#ifndef DROP_FCGI
} /* FCGI_Accept() */
#endif
mdb_destroy(conn);
return 0;
}
void work::run()
{
struct epoll_event ev, events[CLIENTCOUNT]; //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
setnonblocking (listen_st); //把socket设置为非阻塞方式
int epfd = epoll_create(CLIENTCOUNT); //生成用于处理accept的epoll专用的文件描述符
ev.data.fd = listen_st; //设置与要处理的事件相关的文件描述符
ev.events = EPOLLIN | EPOLLERR | EPOLLHUP; //设置要处理的事件类型
epoll_ctl(epfd, EPOLL_CTL_ADD, listen_st, &ev); //注册epoll事件
int st = 0;
while (1)
{
int nfds = epoll_wait(epfd, events, CLIENTCOUNT, -1); //等待epoll事件的发生
if (nfds == -1)
{
printf("epoll_wait failed %s\n", strerror(errno));
break;
}
for (int i = 0; i < nfds; i++)
{
if (events[i].data.fd < 0)
continue;
if (events[i].data.fd == listen_st) //监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。
{
st = socket_accept();//将来自client端的socket描述符设置为非阻塞
if (st >= 0)
{
setnonblocking(st);
ev.data.fd = st;
ev.events = EPOLLIN | EPOLLERR | EPOLLHUP; //设置要处理的事件类型
epoll_ctl(epfd, EPOLL_CTL_ADD, st, &ev);//将来自client端的socket描述符加入epoll
continue;
}
}
if (events[i].events & EPOLLIN) //socket收到数据
{
st = events[i].data.fd;
if (socket_recv(st) <= 0)
{
user_logout(st);
events[i].data.fd = -1;
}
}
if (events[i].events & EPOLLERR) //socket错误。
{
st = events[i].data.fd;
user_logout(st);
events[i].data.fd = -1;
}
if (events[i].events & EPOLLHUP) //socket被挂断。
{
st = events[i].data.fd;
user_logout(st);
events[i].data.fd = -1;
}
}
}
close(epfd);
}
