int main(int argc,char *argv[])
{
void thread_make(int);
int i,nthreads;
socklen_t addrlen;
if(argc<3||argc>4)
err_quit("usage:server [<host>] <port#> <#threads>");
daemon_init(argv[0],0); /*守护进程化当前进程*/
if(argc==3)
{
listenfd=Tcp_listen(NULL,argv[1],&addrlen);
}
else if(argc==4)
{
listenfd=Tcp_listen(argv[1],argv[2],&addrlen);
}
nthreads=atoi(argv[argc-1]);
tptr=Calloc(nthreads,sizeof(pthread_t));
for(i=0; i<nthreads; i++)
{
thread_make(i);
}
for(;;)
pause();
}
int main(int argc,char* argv[])
{
int i, navail, maxfd, nsel, connfd, rc;
socklen_t clilen;
// host info of server
struct sockaddr_in servaddr;
// host info of client
struct sockaddr_in cliaddr;
// value to enable SOL_SOCKET
const int ON = 1;
// initialize server socket
listenfd = socket(PF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(PORT);
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &ON, sizeof(ON));
bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
listen(listenfd, LISTENQ);
// initialize thread pool
// number of threads in the pool
nthreads = 10;
tptr = calloc(nthreads, sizeof(Thread));
iget = iput = 0;
for (i = 0; i < nthreads; ++i)
{
thread_make(i);
}
// register signal SIGINT
signal(SIGINT, sig_int);
// wait for client connection
for (;;)
{
connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &clilen);
echo("[SERVICE] accept a connect from %s.\n", inet_ntoa(cliaddr.sin_addr));
// protect clifd[] and iput/iget
pthread_mutex_lock(&clifd_mutex);
//echo("[SERVER] get lock, thread = [main]\n");
// iput point to next idle position
clifd[iput] = connfd;
if (++iput == MAXCLIENT)
iput = 0;
// the queue overflowed
if (iput == iget)
errexit("[SERVER] Error: too much clients !");
pthread_cond_signal(&clifd_cond);
pthread_mutex_unlock(&clifd_mutex);
}
return 0;
}
int main(int argc, char *argv[])
{
if(argc <= 4)
{
printf("usage: %s ip_address port_number file_name nthreads", basename(argv[0]));
return 1;
}
const char* ip = argv[1];
int port = atoi(argv[2]);
const char* file_name = argv[3];
nthreads = atoi(argv[4]);
tptr = (Thread *)calloc(nthreads, sizeof(nthreads));
int filefd = open(file_name, O_RDONLY);
printf("%d****", filefd);
assert(filefd > 0);
fstat(filefd, &stat_buf);
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET, ip, &address.sin_addr);
address.sin_port = htons(port);
int sock = socket(PF_INET, SOCK_STREAM, 0);
assert(sock >= 0);
int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(sock, 5);
assert(ret != -1);
listenfd = sock;
for (int i = 0; i < nthreads; ++i)
{
thread_make(i);
}
//signal(SIGINT, sig_int);
while (1)
{
pause();
}
close(filefd);
close(sock);
return 0;
}
int main(int argc, char const *argv[])
{
struct sockaddr_in cliaddr, servaddr;
int connfd;
int clilen, addrlen;
int i, nchildren;
pthread_t tid;
if (argc != 3)
{
fprintf(stderr, "usage: serv1 <#port> <#nchildren>\n");
exit(1);
}
if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("socket error");
exit(1);
}
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(atoi(argv[1]));
servaddr.sin_addr.s_addr = htons(INADDR_ANY);
nchildren = atoi(argv[2]);
if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
{
perror("bind error");
exit(1);
}
if (listen(listenfd, LISTENQ) < 0)
{
perror("listen error");
exit(1);
}
Signal(SIGINT, sig_int);
for (i = 0; i < nchildren; ++i)
thread_make(i);
for ( ; ; )
pause();
return 0;
}
// prethread with only main thread doing accept()
void chat_server()
{
printf("chat server start\n");
void sig_chld(int);
pid_t childpid;
socklen_t clilen;
struct sockaddr_in cliaddr ;
int clifd[MAXNCLI];
if(sock_server_init(listenfd,(uint16_t) SERVER_PORT) < 0)
{
return ;
}
signal(SIGCHLD, sig_chld);
char buf[200] = {0};
tptr =(Thread*) calloc(maxthreads, sizeof(Thread));
int i;
iget = iput = 0;
for( i = 0; i < maxthreads ; i++)
{
thread_make(i);
}
for( ; ;)
{
clilen = sizeof(cliaddr);
connfd = accept(listenfd, (SA*)&cliaddr, &clilen);
printf("incoming connection from IP: %s Port: %d\n",
inet_ntop(AF_INET, &cliaddr.sin_addr, buf, sizeof(buf)),
ntohs(cliaddr.sin_port));
pthread_mutex_lock(&clifd_mutex);
clifd[iput] = connfd;
if(++iput == MAXNCLI)
iput = 0;
if(iput == iget)
err_quit("iput = iget ");
pthread_cond_signal(&clifd_cond);
pthread_mutex_unlock(&clifd_mutex);
}//for
}
int
main(int argc, char **argv)
{
int i;
void sig_int(int), thread_make(int);
if (argc == 3)
listenfd = Tcp_listen(NULL, argv[1], &addrlen);
else if (argc == 4)
listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
else
err_quit("usage: serv09 [ <host> ] <port#> <#threads>");
nthreads = atoi(argv[argc-1]);
tptr = Calloc(nthreads, sizeof(Thread));
for (i = 0; i < nthreads; i++)
thread_make(i); /* only main thread returns */
Signal(SIGINT, sig_int);
for ( ; ; )
pause(); /* everything done by threads */
}
int main(int argc, char **argv)
{
int i;
void sig_int(int);
void thread_make(int);
if (argc == 3)
listenfd = tcp_listen(NULL, argv[1], &addrlen);
else if (argc == 4 )
listenfd = tcp_listen(argv[1], argv[2], &addrlen);
else
fprintf(stderr, "usage: server_serv_thread [ <host> ] <port#> <#children>");
nthreads = atoi(argv[argc - 1]);
tptr = calloc(nthreads, sizeof(Thread));
for (i = 0; i < nthreads; i++)
thread_make(i);
signal(SIGINT, sig_int);
for (; ; )
pause();
}
int main(int argc, char *argv[])
{
struct thread *thread;
enum pause_reason reason;
struct variable *var;
#if ! NO_ARGV_0
char *argv0 = "mindy";
#endif
exec_file_name = argv[0];
init_color(false);
init();
thread = thread_make(symbol("main"));
*thread->sp++ = make_raw_function("startup", obj_Nil,
true, obj_False, false,
obj_Nil, obj_ObjectClass,
startup);
while (*++argv != NULL) {
if (strcmp(*argv, "-f") == 0) {
if (*++argv == NULL)
missing_arg("-f");
load(*argv);
#if ! NO_SHARP_BANG
} else if (strcmp(*argv, "-x") == 0) {
if (*++argv == NULL)
missing_arg("-f");
#if ! NO_ARGV_0
if (strcmp(*argv, "-") != 0)
argv0 = *argv;
#endif
load(*argv);
argv += 1;
break;
#endif
#if ! NO_ARGV_0
} else if (strcmp(*argv, "-0") == 0) {
if (*++argv == NULL)
missing_arg("-0");
argv0 = *argv;
#endif
} else {
break;
}
}
#if ! NO_ARGV_0
*thread->sp++ = make_byte_string(argv0); /* pass command name */
#endif
while (*argv != NULL)
*thread->sp++ = make_byte_string(*argv++);
finalize_modules();
while (1) {
thread_restart(thread);
reason = do_stuff();
if (reason != pause_NothingToRun)
invoke_debugger(reason);
var = find_variable(module_BuiltinStuff, symbol("exit"),
false, false);
if (var == NULL)
lose("main undefined?");
thread = thread_make(symbol("exit"));
*thread->sp++ = var->value;
}
return 0;
}
int start_threaded_server ( OCSPD_CONFIG * ocspd_conf )
{
int i = 0;
int rv = 0;
struct sockaddr_in cliaddr;
socklen_t cliaddrlen;
struct sigaction sa;
// Just print a nice log message when exits
atexit(close_server);
if( ocspd_conf->token ) {
if( PKI_TOKEN_init(ocspd_conf->token,
ocspd_conf->token_config_dir, ocspd_conf->token_name)
== PKI_ERR)
{
PKI_log_err( "Can not load default token (%s/%s)",
ocspd_conf->cnf_filename, ocspd_conf->token_name );
exit(1);
}
PKI_TOKEN_cred_set_cb ( ocspd_conf->token, NULL, NULL);
if (PKI_TOKEN_login ( ocspd_conf->token ) != PKI_OK)
{
PKI_log_debug("Can not login into token!");
exit(1);
}
rv = PKI_TOKEN_check(ocspd_conf->token);
if (rv & (PKI_TOKEN_STATUS_KEYPAIR_ERR |
PKI_TOKEN_STATUS_CERT_ERR |
PKI_TOKEN_STATUS_CACERT_ERR))
{
if (rv & PKI_TOKEN_STATUS_KEYPAIR_ERR) PKI_ERROR(PKI_ERR_TOKEN_KEYPAIR_LOAD, NULL);
if (rv & PKI_TOKEN_STATUS_CERT_ERR) PKI_ERROR(PKI_ERR_TOKEN_CERT_LOAD, NULL);
if (rv & PKI_TOKEN_STATUS_CACERT_ERR) PKI_ERROR(PKI_ERR_TOKEN_CACERT_LOAD, NULL);
PKI_log_err("Token Configuration Fatal Error (%d)", rv);
exit(rv);
}
}
/* Initialize all the tokens configured for the single CA entries */
for (i = 0; i < PKI_STACK_elements(ocspd_conf->ca_list); i++)
{
CA_LIST_ENTRY *ca = NULL;
if ((ca = PKI_STACK_get_num( ocspd_conf->ca_list, i )) == NULL)
continue;
if (ca->token_name == NULL)
continue;
if ((ca->token = PKI_TOKEN_new_null()) == NULL)
{
PKI_ERROR(PKI_ERR_MEMORY_ALLOC, NULL);
exit (1);
}
PKI_TOKEN_cred_set_cb ( ocspd_conf->token, NULL, NULL);
rv = PKI_TOKEN_init(ca->token, ca->token_config_dir, ca->token_name);
if (rv != PKI_OK)
{
PKI_ERROR(rv, NULL);
PKI_log_err ( "Can not load token %s for CA %s (%s)",
ca->token_name, ca->ca_id, ca->token_config_dir );
exit (rv);
}
rv = PKI_TOKEN_login(ca->token);
if (rv != PKI_OK)
{
PKI_log_err("Can not login into token (%s)!", ca->ca_id);
exit(rv);
}
rv = PKI_TOKEN_check(ca->token);
if ( rv & (PKI_TOKEN_STATUS_KEYPAIR_ERR |
PKI_TOKEN_STATUS_CERT_ERR |
PKI_TOKEN_STATUS_CACERT_ERR))
{
if (rv & PKI_TOKEN_STATUS_KEYPAIR_ERR) PKI_ERROR(PKI_TOKEN_STATUS_KEYPAIR_ERR, NULL);
if (rv & PKI_TOKEN_STATUS_CERT_ERR) PKI_ERROR(PKI_TOKEN_STATUS_CERT_ERR, NULL);
if (rv & PKI_TOKEN_STATUS_CACERT_ERR) PKI_ERROR(PKI_TOKEN_STATUS_CACERT_ERR, NULL);
PKI_log_err ( "Token Configuration Fatal Error (%d) for ca %s", rv, ca->ca_id);
exit(rv);
}
}
if((ocspd_conf->listenfd = PKI_NET_listen (ocspd_conf->bindUrl->addr,
ocspd_conf->bindUrl->port, PKI_NET_SOCK_STREAM )) == PKI_ERR ) {
PKI_log_err ("Can not bind to [%s],[%d]",
ocspd_conf->bindUrl->addr, ocspd_conf->bindUrl->port);
exit(101);
}
// Now Chroot the application
if ((ocspd_conf->chroot_dir) && (set_chroot( ocspd_conf ) < 1))
{
PKI_log_err ("Can not chroot, exiting!");
exit(204);
}
// Set privileges
if (set_privileges(ocspd_conf) < 1)
{
if (ocspd_conf->chroot_dir != NULL)
{
PKI_log(PKI_LOG_ALWAYS, "SECURITY:: Can not drop privileges! [203]");
PKI_log(PKI_LOG_ALWAYS, "SECURITY:: Continuing because chrooted");
}
else
{
PKI_log(PKI_LOG_ALWAYS, "SECURITY:: Can not drop privileges! [204]");
PKI_log(PKI_LOG_ALWAYS, "SECURITY:: Check User/Group in config file!");
exit(204);
}
}
if((ocspd_conf->threads_list = calloc ( (size_t) ocspd_conf->nthreads,
sizeof(Thread))) == NULL )
{
PKI_log_err ("Memory allocation failed");
exit(79);
}
// Creates the Threads
for (i = 0; i < ocspd_conf->nthreads; i++)
{
if (thread_make(i) != 0)
{
PKI_log_err ("Can not create thread (%d)\n", i );
exit(80);
}
}
// Register the alarm handler
set_alrm_handler();
// Just print a nice log message when killed
signal(SIGTERM, handle_sigterm );
signal(SIGABRT, handle_sigabrt );
// Setting the SIGHUP in order to reload the CRLs
// sa.sa_handler = auto_crl_check;
sa.sa_handler = force_crl_reload;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGHUP, &sa, NULL) == -1)
{
PKI_log_err("Error during setting sig_handler");
exit(1);
}
cliaddrlen = sizeof( cliaddr );
for ( ; ; )
{
// Acquires the Mutex for handling the ocspd_conf->connfd
PKI_MUTEX_acquire ( &ocspd_conf->mutexes[CLIFD_MUTEX] );
if ((ocspd_conf->connfd = PKI_NET_accept(ocspd_conf->listenfd, 0)) == -1)
{
// Provides some information about the error
if (ocspd_conf->verbose || ocspd_conf->debug)
{
char err_str[512];
PKI_log_err("Network Error [%d::%s]", errno,
strerror_r(errno, err_str, sizeof(err_str)));
}
// Returns the connfd MUTEX and restart from the top of the cycle
PKI_MUTEX_release(&ocspd_conf->mutexes[CLIFD_MUTEX]);
continue;
}
// Some debugging information
if (ocspd_conf->debug)
{
if (getpeername(ocspd_conf->connfd, (struct sockaddr*)&cliaddr, &cliaddrlen) == -1)
{
char err_str[512];
PKI_log_err("Network Error [%d::%s] in getpeername", errno,
strerror_r(errno, err_str, sizeof(err_str)));
}
PKI_log(PKI_LOG_INFO, "Connection from [%s]",
inet_ntoa(cliaddr.sin_addr));
}
// Communicate that there is a good socket waiting for a thread to pickup
PKI_COND_broadcast ( &ocspd_conf->condVars[CLIFD_COND] );
PKI_MUTEX_release ( &ocspd_conf->mutexes[CLIFD_MUTEX] );
// Waits for a thread to successfully pickup the socket
PKI_MUTEX_acquire ( &ocspd_conf->mutexes[SRVFD_MUTEX] );
while (ocspd_conf->connfd > 2)
{
PKI_COND_wait ( &ocspd_conf->condVars[SRVFD_COND],
&ocspd_conf->mutexes[SRVFD_MUTEX] );
}
PKI_MUTEX_release ( &ocspd_conf->mutexes[SRVFD_MUTEX] );
}
return(0);
}
int main(){
int LISTEN_BACKLOG=10;
int sfd=socket(AF_INET,SOCK_STREAM,0);
struct sockaddr_in my_addr, their_addr;
if(sfd==-1){
fprintf(stderr,"socket error\n");
exit(1);
}
//struct sockaddr addr;
my_addr.sin_family=AF_INET;
my_addr.sin_port = htons(9100);
my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(my_addr.sin_zero), 8);
if(bind(sfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1){
fprintf(stderr,"bind error\n");
exit(1);
}
if(listen(sfd,LISTEN_BACKLOG)==-1){
fprintf(stderr,"listen error\n");
exit(1);
}
int nfds;
m_epollfd=epoll_create(QUEUELEN);
struct epoll_event m_epollev[QUEUELEN];
struct epoll_event ev;
ev.data.fd=sfd;
ev.events=EPOLLIN|EPOLLET;
epoll_ctl(m_epollfd,EPOLL_CTL_ADD,sfd,&ev);
int sockfd=0;int i=0;
int sock;
socklen_t sin_size;
thread_make(THREAD_NUM);
while(1){
// epoll
//if recv,lock sockArray[sockRear++]=sock; unlock;
//read rear=(rear+1)%QUEUELEN sockArray[rear]=sock;
nfds=epoll_wait(m_epollfd,m_epollev,QUEUELEN,-1);
for(i=0;i<nfds;i++)
{
sockfd=m_epollev[i].data.fd;
struct epoll_event _event=m_epollev[i];
if(sfd==sockfd)
{
//accept
sin_size=sizeof(struct sockaddr);
sock=accept(sfd,(void*)&their_addr,&sin_size);
ev.data.fd=sock;
ev.events=EPOLLIN|EPOLLET;
epoll_ctl(m_epollfd,EPOLL_CTL_ADD,sock,&ev);
}
else if(_event.events&EPOLLIN)
{
//lock
pthread_mutex_lock(&mlock);
if(sockFront==((sockRear+1)%QUEUELEN))
{
printf("GET TO THE MAX LIMIT %d\n",QUEUELEN);
pthread_mutex_unlock(&mlock);
continue;
}
sockRear=(sockRear+1)%QUEUELEN;
sockArray[sockRear]=sockfd;
printf("here we are %d\n",sockfd);
pthread_mutex_unlock(&mlock);
pthread_cond_signal(&m_condlock);
//unlock
}
else
printf("epoll:else\n");
}
}
}
