int main(int argc, char**argv) {
const char *pidfile = "/var/run/ftp_multithread_server.pid";
if(write_pid_lock(pidfile) < 0) {
printf("%s: already running\n", argv[0]);
return 0;
}
sockfd = socket_server(PORTSERVER, MAX_CLIENT);
if (sockfd < 0) {
Error("socket server");
return -1;
}
if(sem_init(&client_sem, 0, MAX_CLIENT) < 0) {
close(sockfd);
Error("exit now");
return -1;
}
memset(client_id, 0, sizeof(client_id));
atexit(at_exit_cleanup);
while (1) {
size_t client_addr_len;
struct client_args client;
pthread_t thread;
int ret;
if(sem_wait(&client_sem) < 0) {
perror("sem_wait");
break;
}
bzero(&client, sizeof(client));
client_addr_len = sizeof(client.addr);
client.sockfd = accept(sockfd, (struct sockaddr *) &client.addr,
&client_addr_len);
if (client.sockfd < 0) {
Error("accept");
break;
}
//client count
Info("client connect from %s", inet_ntoa(client.addr.sin_addr));
void *thread_args = thread_alloc_args(&client);
ret = pthread_create(&thread, NULL, thread_client, thread_args);
if (ret != 0) {
Error("pthread_create");
if(thread_args != NULL)
free(thread_args);
if(sem_post(&client_sem) < 0) {
Error("sem_wait");
}
continue;
}
pthread_detach(thread);
}
return 0;
}
int main(int argc, char* argv[]) {
gint error = 0;
options_init(argc - 1, argv + 1);
INFO("Starting up.");
descriptor_init();
DEBUG("Disabling SIGPIPE.");
signal(SIGPIPE, SIG_IGN);
DEBUG("Creating ZeroMQ context.");
gpointer zmq_context = zmq_init(options_zmq_io_threads());
if (zmq_context == NULL) {
PERROR("main(zmq_init)");
error = 1;
goto err0;
}
DEBUG("Creating server on port %s.", options_port());
gint socket = socket_server(options_port());
if (socket == -1) {
error = 1;
goto err1;
}
INFO("Initialising Lua API.");
lua_api_init(zmq_context, argc - 1, argv + 1);
lua_State* lua = lua_api_get();
DEBUG("Running " LUA_START_FILE);
if (luaL_dofile(lua, LUA_START_FILE) == 1) {
ERROR("%s", lua_tostring(lua, -1));
error = 1;
goto err2;
}
io_mainloop(socket);
err2:
DEBUG("Closing server socket.");
socket_close(socket);
err1:
DEBUG("Terminating ZeroMQ context.");
/* This is separate from lua_api_deinit() to prevent zmq_term() from
blocking forever. */
lua_zmq_deinit();
zmq_term(zmq_context);
err0:
DEBUG("Enabling SIGPIPE.");
signal(SIGPIPE, SIG_DFL);
options_deinit();
descriptor_deinit();
if (lua_api_get() != NULL) {
DEBUG("Closing Lua state.");
lua_api_deinit();
}
return error;
}
int main (int argc, char** argv)
{
int server;
server = socket_open();
socket_bind( server, PORT );
socket_listen( server, LISTEN );
socket_server( server );
return 0;
}
int main(int argc, char **argv) {
int sockfd;
sockfd = socket_server(SERVERPORT, MAXCONNECT);
if (sockfd < 0) {
fprintf(stderr, "socket error");
return -1;
}
CLIENT client;
client.sockfd = -1;
while (1) {
int max_fd;
fd_set readfds;
struct timeval to;
FD_ZERO(&readfds);
FD_SET(sockfd, &readfds);
if (client.sockfd >= 0)
FD_SET(client.sockfd, &readfds);
max_fd = sockfd > client.sockfd ? sockfd + 1 : client.sockfd + 1;
to.tv_sec = 1;
to.tv_usec = 0;
if (!select(max_fd, &readfds, NULL, NULL, &to))
continue;
if (client.sockfd >= 0 && FD_ISSET(client.sockfd, &readfds)) {
//client handle data
process_client(&client);
} else if (FD_ISSET(sockfd, &readfds)) {
//new client
accept_client(&client, sockfd);
}
} //while(1)
}
/*
* Nutella SERVER
*/
int main(int argc, char** argv)
{
port = PORT;
request_address = M_REQ_ADDR;
request_port = M_REQ_PORT;
response_address = M_RES_ADDR;
response_port = M_RES_PORT;
int c;
while((c = getopt(argc, argv, "d:q:s:p:h")) != EOF){
switch(c){
case 'd':
movie_dir = optarg;
break;
case 'q':
request_address = optarg;
request_port = get_port(request_address);
break;
case 's':
response_address = optarg;
response_port = get_port(response_address);
break;
case 'p':
port = atoi(optarg);
break;
case 'h':
default:
usage(argv);
break;
}
}
if(!movie_dir){
usage(argv);
}
//get hostname
char hostname[256];
if((gethostname(hostname, 256)) < 0){
fprintf(stderr, "Unable to get hostname\n");
exit(1);
}
sprintf(connectAddr, "%s:%d", hostname, port);
printf("connectTo: %s\n", connectAddr);
int mdlen = strlen(movie_dir);
if(movie_dir[mdlen-1] == '/'){
movie_dir[mdlen-1] = '\0';
}
//create a thread to handle multicast request/response loop
pthread_t query_thread;
pthread_create(&query_thread, NULL, monitor_queries, NULL);
int sock = socket_server(port);
while(1){
int client = socket_accept(sock);
if(client > 0){
int pid = fork();
if(pid == 0){
char* request = socket_read(client);
printf("Streaming %s...\n", request);
stream_file(client, request);
socket_write(client, "end\n"); //end stream with blank frame
close(client);
printf("done streaming \"%s\"\n", request);
exit(0);
}
}
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
socket_server();
return 0;
}
int
serverWorkerSockets(const std::string& serverUri,
const std::string& workerUri,
int nbThreads,
WorkerParam params,
bool useSsl,
const std::string& cafile) {
boost::shared_ptr<zmq::context_t> context = \
boost::make_shared<zmq::context_t>(1);
zmq::socket_t socket_server(*context, ZMQ_ROUTER);
zmq::socket_t socket_workers(*context, ZMQ_DEALER);
// bind the sockets
try {
socket_server.bind(serverUri.c_str());
std::string logMsg = boost::str(boost::format("[INFO] Server started on %1%") % serverUri);
std::cerr << logMsg <<"\n";
LOG(logMsg, LogInfo);
std::cerr << "[INFO] See the log file for runtime info\n";
} catch (const zmq::error_t& e) {
std::string logMsg = boost::str(boost::format("[ERROR] zmq socket_server (%1%) binding failed (%2%)")
% serverUri % e.what());
LOG(logMsg, LogErr);
exit(1);
}
try {
socket_workers.bind(workerUri.c_str());
} catch (const zmq::error_t& e) {
std::string logMsg = boost::str(boost::format("[ERROR] zmq socket_worker (%1%) binding failed (%2%)")
% workerUri % e.what());
LOG(logMsg, LogErr);
exit(1);
}
// Create our pool of threads
ThreadPool pool(nbThreads);
for (int i = 0; i < nbThreads; ++i) {
if (useSsl) {
pool.submit(WorkerType(context, workerUri, i, params, useSsl, cafile));
} else {
pool.submit(WorkerType(context, workerUri, i, params, false, ""));
}
}
// connect our workers threads to our server via a queue
do {
try {
zmq::device(ZMQ_QUEUE, socket_server, socket_workers);
break;
} catch (const zmq::error_t& e) {
if (EINTR == e.num()) {
continue;
} else {
LOG(boost::str(boost::format("[ERROR] zmq device creation failed (%1%)\n")
% e.what()), LogErr);
exit(1);
}
}
} while(true);
return 0;
}
int main()
{
char SERVER_IP[] = "192.168.43.69";
int port = 9511;
socket_server(SERVER_IP, port);
}
