void TcpServer::init(){
try{
InitWinSock();
tcpSocket = mksock(SOCK_STREAM);
sockaddr_in local;
local.sin_family=AF_INET;
local.sin_port= htons(SERVER_PORT);
local.sin_addr.s_addr = htonl(INADDR_ANY);
int nResult=bind(tcpSocket,(sockaddr*)&local,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
throw Exception("bind error");
listen(tcpSocket,10);
//一下代码获得IP和计算机名
char name[255];
char* ip = NULL;
PHOSTENT hostInfo;
if (gethostname(name,sizeof(name)) == 0)
{
if (hostInfo = gethostbyname(name))
{
ip = inet_ntoa(*(in_addr*)*(hostInfo->h_addr_list));
}
}
printf("%s:%d--%s\n",ip,SERVER_PORT,name);
HANDLE threadhandle = CreateThread(NULL, 0, waitForConnect, (LPVOID)this, NULL, NULL);
CloseHandle(threadhandle);
}
catch(Exception &e)
{
printf(e.GetMessage());
}
}
void openlog_async(const char *ident, int option, int facility)
{
if (ident)
log_tag = ident;
log_opts = option;
if (facility != 0 && (facility &~ LOG_FACMASK) == 0)
log_fac = facility;
if (log_opts & LOG_NDELAY)
log_fd = mksock(SOCK_DGRAM);
}
int servsock(char *host, char * service, char * proto, struct sockaddr_in *sin, int qlen)
{
int sd;
// Make socker and return socker descriptor
if ((sd = mksock(host, service, proto, (struct sockaddr_in *) sin)) == -1)
return -1;
// Bind attaches to socker local address sin having size sin
if (bind(sd, (struct sockaddr *) sin, sizeof ( *sin)) < 0) {
perror("Error binding socket");
return -1;
}
// Listen for connections if protocol is tcp
if (strcmp(proto, "tcp") == 0) {
if (listen(sd, qlen) == -1) {
perror("Error switching socket to passive mode");
return -1;
}
}
return sd;
}
void log_write_async(void)
{
ssize_t rc;
int fd, tried_stream = 0;
struct log_entry *tmp;
while (entries)
{
if (log_fd == -1 &&
(log_fd = mksock(SOCK_DGRAM)) == -1)
goto fail;
connection_good = 1;
if ((rc = send(log_fd,
entries->payload + entries->offset,
entries->length,
MSG_NOSIGNAL)) != -1)
{
entries->length -= rc;
entries->offset += rc;
connection_good = 1;
if (entries->length == 0)
goto free;
continue;
}
if (errno == EINTR)
continue;
if (errno == EAGAIN)
return;
/* *BSD, returns this instead of blocking? */
if (errno == ENOBUFS)
{
connection_good = 0;
return;
}
/* A stream socket closed at the other end goes into EPIPE
forever, close and re-open. */
if (errno == EPIPE)
goto reopen_stream;
if (errno == ECONNREFUSED ||
errno == ENOTCONN ||
errno == EDESTADDRREQ ||
errno == ECONNRESET)
{
/* socket went (syslogd down?), try and reconnect. If we fail,
stop trying until the next call to my_syslog()
ECONNREFUSED -> connection went down
ENOTCONN -> nobody listening
(ECONNRESET, EDESTADDRREQ are *BSD equivalents) */
struct sockaddr_un logaddr;
logaddr.sun_family = AF_LOCAL;
strncpy(logaddr.sun_path, _PATH_LOG, sizeof(logaddr.sun_path));
/* Got connection back? try again. */
if (connect(log_fd, (struct sockaddr *)&logaddr, sizeof(logaddr)) != -1)
continue;
/* errors from connect which mean we should keep trying */
if (errno == ENOENT ||
errno == EALREADY ||
errno == ECONNREFUSED ||
errno == EISCONN ||
errno == EINTR ||
errno == EAGAIN)
{
/* try again on next syslog() call */
connection_good = 0;
return;
}
/* we start with a SOCK_DGRAM socket, but syslog may want SOCK_STREAM */
if (!tried_stream && errno == EPROTOTYPE)
{
reopen_stream:
tried_stream = 1;
close(log_fd);
if ((log_fd = mksock(SOCK_STREAM)) != -1)
continue;
}
}
fail:
tried_stream = 0;
/* give up - try to write to console if we've been asked
take care not to block in open() or write() */
if ((log_opts & LOG_CONS) &&
(fd = open(_PATH_CONSOLE, O_WRONLY | O_NONBLOCK, 0)) != -1)
{
char *start = strchr(entries->payload, '>') + 1;
int flags = fcntl(fd, F_GETFL);
if (flags != -1)
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
entries->length -= start - entries->payload;
/* move down to remove the tag, and make room for the \r\n */
memmove(entries->payload, start, entries->length);
entries->payload[entries->length - 1] = '\r';
entries->payload[entries->length] = '\n';
write(fd, entries->payload, entries->length + 1);
close(fd);
}
free:
tmp = entries;
entries = tmp->next;
tmp->next = free_entries;
free_entries = tmp;
if (entries_lost != 0)
{
int e = entries_lost;
entries_lost = 0; /* avoid wild recursion */
syslog_async(LOG_WARNING, "async_syslog overflow: %d log entries lost", e);
}
continue;
}
}
static int restore_special(struct asfd *asfd, struct sbuf *sb,
const char *fname, enum action act, struct cntr *cntr,
enum protocol protocol)
{
int ret=0;
char *rpath=NULL;
#ifdef HAVE_WIN32
logw(asfd, cntr, "Cannot restore special files to Windows: %s\n", fname);
goto end;
#else
struct stat statp=sb->statp;
if(act==ACTION_VERIFY)
{
cntr_add(cntr, CMD_SPECIAL, 1);
return 0;
}
if(build_path(fname, "", &rpath, NULL))
{
// failed - do a warning
if(restore_interrupt(asfd, sb,
build_msg("build path failed: %s", fname),
cntr, protocol))
ret=-1;
goto end;
}
if(S_ISFIFO(statp.st_mode))
{
if(mkfifo(rpath, statp.st_mode) && errno!=EEXIST)
do_logw(asfd, cntr,
"Cannot make fifo: %s\n", strerror(errno));
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, cntr);
cntr_add(cntr, CMD_SPECIAL, 1);
}
}
else if(S_ISSOCK(statp.st_mode))
{
if(mksock(rpath))
do_logw(asfd, cntr,
"Cannot make socket: %s\n", strerror(errno));
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, cntr);
cntr_add(cntr, CMD_SPECIAL, 1);
}
}
#ifdef S_IFDOOR // Solaris high speed RPC mechanism
else if (S_ISDOOR(statp.st_mode))
do_logw(asfd, cntr,
"Skipping restore of door file: %s\n", fname);
#endif
#ifdef S_IFPORT // Solaris event port for handling AIO
else if (S_ISPORT(statp.st_mode))
do_logw(asfd, cntr,
"Skipping restore of event port file: %s\n", fname);
#endif
else if(mknod(fname, statp.st_mode, statp.st_rdev) && errno!=EEXIST)
do_logw(asfd, cntr, "Cannot make node: %s\n", strerror(errno));
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, cntr);
cntr_add(cntr, CMD_SPECIAL, 1);
}
#endif
end:
free_w(&rpath);
return ret;
}
int main(int argc, char* argv[]) {
if(argc < 4){
perror("Params format: <HOST> <PORT> <FILENAME>");
exit(EXIT_SUCCESS);
}
char *host = argv[1], *service = argv[2], *proto = "tcp";
const char *filename = argv[3];
struct sockaddr_in sin;
int sd, n;
FILE* fd;
struct stat st;
char offset[1024], buffer[1024];
// Open file and see if it exists
if( access( filename, F_OK ) != -1 ) {
stat(filename, &st);
sprintf(offset, "%lld", (long long) st.st_size);
} else {
strcpy(offset, "0");
}
printf("Requested file offset: %s\n", offset);
if ((sd = mksock(host, service, proto, &sin)) == -1) {
perror("\nОшибка при создании сокета: ");
exit(EXIT_FAILURE);
}
if (connect(sd, (struct sockaddr *) &sin, sizeof(sin) ) < 0 ) {
perror("\nОшибка при соединении с сервером: ");
exit(EXIT_FAILURE);
}
if( send(sd, offset, strlen(offset), 0) < 0 ) {
perror("\nОшибка при отправке смещения файла: ");
exit(EXIT_FAILURE);
}
if((fd = fopen(filename, "a")) == NULL ) {
perror("\nОшибка при открытии файла");
exit(EXIT_FAILURE);
}
while ( (n = read(sd, &buffer, sizeof(buffer))) > 0 ) {
// Write to file
stat(filename, &st);
fwrite(buffer, sizeof(buffer[0]), n, fd);
fflush(fd);
printf("Written %d bytes at file offset %lld.\n",n, (long long) st.st_size);
}
fclose(fd);
if ( n < 0 ) {
perror("\nError receiving file:");
exit(EXIT_FAILURE);
}
stat(filename, &st);
printf("Total file size: %jd.\n",(intmax_t)st.st_size);
close(sd);
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
try{
InitWinSock();
SOCKET PrimaryUDP;
PrimaryUDP = mksock(SOCK_DGRAM);
sockaddr_in local;
local.sin_family=AF_INET;
local.sin_port= htons(SERVER_PORT);
local.sin_addr.s_addr = htonl(INADDR_ANY);
int nResult=bind(PrimaryUDP,(sockaddr*)&local,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
throw Exception("bind error");
sockaddr_in sender;
stMessage recvbuf;
memset(&recvbuf,0,sizeof(stMessage));
// 开始主循环.
// 主循环负责下面几件事情:
// 一:读取客户端登陆和登出消息,记录客户列表
// 二:转发客户p2p请求
for(;;)
{
int dwSender = sizeof(sender);
int ret = recvfrom(PrimaryUDP, (char *)&recvbuf, sizeof(stMessage), 0, (sockaddr *)&sender, &dwSender);
if(ret <= 0)
{
printf("recv error");
continue;
}
else
{
int messageType = recvbuf.iMessageType;
switch(messageType){
case LOGIN:
{
// 将这个用户的信息记录到用户列表中
printf("has a user login : %s\n", recvbuf.message.loginmember.userName);
stUserListNode *currentuser = new stUserListNode();
strcpy(currentuser->userName, recvbuf.message.loginmember.userName);
currentuser->ip = ntohl(sender.sin_addr.S_un.S_addr);
currentuser->port = ntohs(sender.sin_port);
ClientList.push_back(currentuser);
// 发送已经登陆的客户信息
int nodecount = (int)ClientList.size();
sendto(PrimaryUDP, (const char*)&nodecount, sizeof(int), 0, (const sockaddr*)&sender, sizeof(sender));
for(UserList::iterator UserIterator=ClientList.begin();
UserIterator!=ClientList.end();
++UserIterator)
{
sendto(PrimaryUDP, (const char*)(*UserIterator), sizeof(stUserListNode), 0, (const sockaddr*)&sender, sizeof(sender));
}
break;
}
case LOGOUT:
{
// 将此客户信息删除
printf("has a user logout : %s\n", recvbuf.message.logoutmember.userName);
UserList::iterator removeiterator = NULL;
for(UserList::iterator UserIterator=ClientList.begin();
UserIterator!=ClientList.end();
++UserIterator)
{
if( strcmp( ((*UserIterator)->userName), recvbuf.message.logoutmember.userName) == 0 )
{
removeiterator = UserIterator;
break;
}
}
if(removeiterator != NULL)
ClientList.remove(*removeiterator);
break;
}
case P2PTRANS:
{
// 某个客户希望服务端向另外一个客户发送一个打洞消息
printf("%s wants to p2p %s\n",inet_ntoa(sender.sin_addr),recvbuf.message.translatemessage.userName);
stUserListNode node = GetUser(recvbuf.message.translatemessage.userName);
sockaddr_in remote;
remote.sin_family=AF_INET;
remote.sin_port= htons(node.port);
remote.sin_addr.s_addr = htonl(node.ip);
in_addr tmp;
tmp.S_un.S_addr = htonl(node.ip);
printf("the address is %s,and port is %d\n",inet_ntoa(tmp), node.port);
stP2PMessage transMessage;
transMessage.iMessageType = P2PSOMEONEWANTTOCALLYOU;
transMessage.iStringLen = ntohl(sender.sin_addr.S_un.S_addr);
transMessage.Port = ntohs(sender.sin_port);
sendto(PrimaryUDP,(const char*)&transMessage, sizeof(transMessage), 0, (const sockaddr *)&remote, sizeof(remote));
break;
}
case GETALLUSER:
{
int command = GETALLUSER;
sendto(PrimaryUDP, (const char*)&command, sizeof(int), 0, (const sockaddr*)&sender, sizeof(sender));
int nodecount = (int)ClientList.size();
sendto(PrimaryUDP, (const char*)&nodecount, sizeof(int), 0, (const sockaddr*)&sender, sizeof(sender));
for(UserList::iterator UserIterator=ClientList.begin();
UserIterator!=ClientList.end();
++UserIterator)
{
sendto(PrimaryUDP, (const char*)(*UserIterator), sizeof(stUserListNode), 0, (const sockaddr*)&sender, sizeof(sender));
}
break;
}
}
}
}
}
catch(Exception &e)
{
printf(e.GetMessage());
return 1;
}
return 0;
}
int main (int argc, char ** argv) {
int sock;
sqlite3 * db;
struct smsnode * sq;
struct thrdarg arg;
pthread_attr_t attr;
pthread_t tid;
const char * dbi;
pid_t pid, sid;
//signal (SIGHUP, signal_handler);
//signal (SIGTERM, signal_handler);
//signal (SIGINT, signal_handler);
//signal (SIGQUIT, signal_handler);
/*pid = fork ();
if (pid < 0) exit (EXIT_FAILURE);
if (pid > 0) exit (EXIT_SUCCESS);
umask (0);
sid = setsid();
if (sid < 0) exit (EXIT_FAILURE);
if (chroot("/") < 0) exit (EXIT_FAILURE);
if (chdir("/") < 0) exit (EXIT_FAILURE);
if (setuid(CRYPTO_DAEMON_UID) < 0) exit (EXIT_FAILURE);
if (setuid(CRYPTO_DAEMON_GID) < 0) exit (EXIT_FAILURE);
close (STDIN_FILENO);
close (STDOUT_FILENO);
close (STDERR_FILENO);*/
dbi = "create table if not exists users (login varchar(32) primary key, clear varchar(64), phone varchar(10), otp varchar(32), expire bigint, active tinyint)";
if (sqlite3_open("/tmp/user", &db)) {
printf ("error opening database");
exit (1);
}
else
sqlite3_exec (db, dbi, 0, 0, 0);
sock = mksock ("/tmp/otpd");
sq = (struct smsnode *) malloc (sizeof(struct smsnode));
sq->status = -1;
sq->next = sq;
sq->prev = sq;
arg.s = 0;
arg.sq = sq;
arg.db = db;
pthread_attr_init (&attr);
pthread_create (&tid, &attr, &sms_thread, (void *) &arg);
while (1) (void) acsock (sock, db, sq);
close (sock);
sqlite3_close (db);
return 0;
}
main( void)
{
char * host = "0.0.0.0";
char * service = "2525";
char * proto = "tcp";
//char * proto = "sctp";
struct sockaddr_in sin, remote;
struct tm *tp;
time_t t;
int i, sd, rsd, rlen, readed, pid;
char buf[513], t_str[512];
if ( (sd = mksock( host, service, proto, &sin)) == -1)
{
perror( "Ошибка при создании сокета");
return 1;
}
printf( "Адрес сервера %s = %s\n", host, (char *) (inet_ntoa( sin.sin_addr)));
printf( "Адрес порта сервера %s = %X\n", service, sin.sin_port);
i = 1;
i = setsockopt( sd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof( &i));
if( i != 0) perror("Опция сокета (SOL_SOCKET, SO_REUSEADDR))");
if( bind( sd, (struct sockaddr *) &sin, sizeof( sin)) < 0)
{
perror( "Ошибка при привязке сокета");
return 1;
}
for ( i=0; i<CHILDS; i++)
{
pid = fork();
switch ( pid)
{
case -1:
perror( "Не создается дочерний процесс");
break;
case 0:
pid = i+1;
i=CHILDS+1;
break;
default:
pid=0;
}
}
if ( listen( sd, 0) == -1)
{
perror( "Ошибка при переводе сокета в пассивный режим");
return 1;
}
while(1)
{
rlen = sizeof( remote);
rsd = accept( sd, (struct sockaddr *)&remote, &rlen);
fprintf( stderr, "Process %d accepted connection\n", pid);
t = time( NULL);
tp = localtime( &t);
strftime( t_str, 512, "%a, %d %b %Y %T %z", tp);
snprintf( buf, 512, "Server [%d]: %s\n", pid, t_str );
send(rsd, buf, strlen(buf), 0);
close( rsd);
}
return 0;
}
int main(int argc, char* argv[])
{
const char my_ip[] = "10.101.0.15";
const char udpecho_ip[] = "10.101.0.16";
SOCKET sock[2];
char buf[] = "Hello, world!";
sock[0] = mksock();
sock[1] = mksock();
int epollfd = epoll_create(1);
if (epollfd == -1)
error(1, errno, "Error epoll creating");
struct epoll_event ev[2];
ev[0].events = EPOLLIN | EPOLLPRI;
ev[0].data.fd = sock[0];
ev[1].events = EPOLLIN | EPOLLPRI;
ev[1].data.fd = sock[1];
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sock[0], &ev[0]) == -1)
error(1, errno, "Error adding event 1 to epoll");
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sock[1], &ev[1]) == -1)
error(1, errno, "Error adding event 2 to epoll");
struct sockaddr_in addr;
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(udpecho_ip);
addr.sin_port = htons(5100);
struct sockaddr_in self;
memset(&self, 0, sizeof(struct sockaddr_in));
self.sin_family = AF_INET;
self.sin_addr.s_addr = inet_addr(my_ip);
self.sin_port = htons(5101);
if (RawSendTo(sock[0], buf, sizeof(buf), 0,
(struct sockaddr*)&self,
(struct sockaddr*)&addr,
sizeof(struct sockaddr_in)) == 0)
{
error(1, errno, "Error RawSendTo data.");
}
struct epoll_event events[2];
memset(events, 0, sizeof(struct epoll_event)*2);
while(1)
{
size_t nfds = epoll_wait(epollfd, events, 2 + 1, 1000);
size_t i = 0;
if (nfds == -1)
error(1, errno, "Error calling epoll");
for (i = 0; i < nfds; ++i)
{
if ((events[i].events & EPOLLIN) == EPOLLIN ||
(events[i].events & EPOLLPRI) == EPOLLPRI)
{
struct sockaddr_storage tmp_addr;
socklen_t len = sizeof(tmp_addr);
char rbuf[65355];
memset(rbuf, 0, sizeof(buf));
int rs = recvfrom(events[i].data.fd, rbuf, sizeof(rbuf), 0,
(struct sockaddr*)&tmp_addr, &len);
if(rs < 0)
error(1, errno, "Error receiving data from socket.");
char tmp[50];
if(inet_ntop(tmp_addr.ss_family, GetAddr((struct sockaddr*)&tmp_addr),
tmp, sizeof(tmp)) == NULL)
{
error(1, errno, "Error converting addr to string.");
}
printf("Socket %lu (from %s): %s\n", i, tmp, rbuf + 28);
}
}
printf("heartbeat\n");
fflush(stdout);
}
return 0;
}
