int main(int argc, char* argv[])
{
int port = 23;
thread_func func = thread_receive;
if (argc > 1) {
port = atoi(argv[1]);
}
if (argc > 2 && strcmp(argv[2], "send") == 0) {
func = thread_send;
}
signal(SIGINT, signal_func);
int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
struct sockaddr_in addr, remote;
socklen_t addrlen = sizeof(addr);
memset(&addr, 0, addrlen);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = INADDR_ANY;
setreuse(sock);
if(bind(sock, (struct sockaddr *)&addr, addrlen) < 0) {
fprintf(stderr, "bind %s\n", strerror(errno));
return 1;
}
setrcvbuflen(sock, RCVBUF_LENGTH);
setsndbuflen(sock, SNDBUF_LENGTH);
if(listen(sock, 5) < 0) {
fprintf(stderr, "listen %s\n", strerror(errno));
return 1;
}
int clisock = -1;
while (1) {
memset(&remote, 0, addrlen);
if ((clisock = accept(sock, (struct sockaddr *)&remote, &addrlen)) < 0) {
fprintf(stderr, "accept %s\n", strerror(errno));
return 1;
}
printf("accept client address %s:%d socket:%d MSS:%d\n", inet_ntoa(remote.sin_addr), ntohs(remote.sin_port), clisock, getMSS(clisock));
pthread_t th;
pthread_attr_t thattr;
pthread_attr_init(&thattr);
pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_DETACHED);
pthread_create(&th, &thattr, func, &clisock);
}
close(sock);
return 0;
}
static void connect_redis(connector_t pconredis)
{
int ret = 0;
int sockfd = INVALID_ID;
struct sockaddr_in redis_addr;
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
print_log(LOG_TYPE_ERROR, "socket, file = %s, line = %d", __FILE__, __LINE__);
return;
}
setnonblock(sockfd);
setreuse(sockfd);
set_tcp_fastclose(sockfd);
bzero(&redis_addr, sizeof(redis_addr));
redis_addr.sin_family = AF_INET;
redis_addr.sin_port = htons(pconredis->port);
if (inet_pton(AF_INET, pconredis->ip, &redis_addr.sin_addr) < 0)
{
close(sockfd);
print_log(LOG_TYPE_ERROR, "inet_pton, file = %s, line = %d", __FILE__, __LINE__);
return;
}
ret = connect(sockfd, (struct sockaddr *)&redis_addr, sizeof(redis_addr));
if (ret == 0)
{
pconredis->sockfd = sockfd;
connector_sig_read(pconredis);
pconredis->state = CONN_STATE_RUN;
}
else if (errno == EINPROGRESS)
{
pconredis->sockfd = sockfd;
connector_sig_write(pconredis);
pconredis->state = CONN_STATE_CONNECTING;
}
else
{
close(sockfd);
print_log(LOG_TYPE_ERROR, "connect error, file = %s, line = %d", __FILE__, __LINE__);
}
}
peer_t *tcpbus_server(const char *in_addr,
const char *port,
void (*on_connect)(peer_t*),
void (*on_disconnect)(peer_t*),
void (*on_input)(peer_t*),
void *ext_ptr)
{
int ret;
struct sockaddr_in addr;
peer_t *peer;
jlog(L_NOTICE, "server ready: %s:%s", in_addr, port);
peer = calloc(sizeof(peer_t), 1);
peer->type = TCPBUS_SERVER;
peer->on_connect = on_connect;
peer->on_disconnect = on_disconnect;
peer->on_input = on_input;
peer->recv = tcpbus_recv;
peer->send = tcpbus_send;
peer->disconnect = tcpbus_disconnect;
peer->buffer = NULL;
peer->ext_ptr = ext_ptr;
peer->socket = socket(PF_INET, SOCK_STREAM, 0);
if (peer->socket < 0) {
jlog(L_NOTICE, "socket failed: %s", strerror(errno));
free(peer);
return NULL;
}
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_port = htons(atoi(port));
addr.sin_addr.s_addr = inet_addr(in_addr);
ret = setreuse(peer->socket);
if (ret < 0) {
jlog(L_NOTICE, "setreuse: %s", strerror(errno));
close(peer->socket);
free(peer);
return NULL;
}
ret = bind(peer->socket, (const struct sockaddr *)&addr, sizeof(const struct sockaddr));
if (ret < 0) {
jlog(L_NOTICE, "bind failed: %s %s", strerror(errno), in_addr);
close(peer->socket);
free(peer);
return NULL;
}
/* The backlog parameter defines the maximum length the
* queue of pending connection may grow to. LISTEN(2)
*/
ret = listen(peer->socket, CONN_BACKLOG);
if (ret < 0) {
jlog(L_NOTICE, "set_nonblocking failed: %s", strerror(errno));
close(peer->socket);
free(peer);
return NULL;
}
ret = tcpbus_ion_add(peer->socket, peer);
if (ret < 0) {
jlog(L_NOTICE, "tcpbus_ion_add failed: %s", strerror(errno));
close(peer->socket);
free(peer);
return NULL;
}
return peer;
}
/**
* main()
*/
int main()
{
int lsd = -1; //listening socketdescriptor
int asd = -1; //new socketdescriptor from accept
int port = TM_PORT_ECHO; //default port
int error = 0;
int result;
//int i;
struct sockaddr_in addr;
struct sockaddr_in claddr;
char ClientIP[17];
int taskrdy = -1;
initServer();
startDK40Task();
initSubServerTask(lsd,error);
RTX_Sleep_Time(100);
lsd = openListenSocket(lsd,error);
#ifdef TCPSERV_DEBUG
printf("\r\nTCP Echoserver: Öffnen einen Socket %d",lsd);
#endif
/**
* Setzt den horchenden Socket auf Wiederverwendbar ein
* @param lsd Den Socketdeskriptor des horchenden Sockets
* @param error Fehlercode
* @return (0) für erfolgreich, ungleich (0) für fehler
*/
result = setreuse(lsd,&error);
#ifdef TCPSERV_DEBUG
if(result == API_ERROR){
printf("\r\nTCP Echoserver: Set reuse failed %d",error);
}
#endif
addr.sin_family = PF_INET;
addr.sin_port = htons(port); //Konvertierung von Little Endian zu Big Endian
addr.sin_addr.s_addr = 0L;
result = bind(lsd,(struct sockaddr *)&addr,&error);
if(result == API_ERROR){
printf("\r\nTCP Echoserver, Bind socket failed %d",error);
shutDownServer(lsd,error);
}//(result == API_ERROR)
/*
* Endlosschleife, horcht und baut Verbindungen auf
*/
while(1)
{
/**
* listen
*/
result = listen(lsd, MAX_SERVER, &error);
if(result == API_ERROR){
printf("\r\nTCP Echoserver, listen failed %d",error);
shutDownServer(lsd,error);
}//if(result == API_ERROR)
/**
* accept , establish a connection
*/
claddr.sin_family = PF_INET;
claddr.sin_port = 0; //clear
claddr.sin_addr.s_addr = 0L; //clear
result = accept(lsd,(struct sockaddr *)&claddr,&error);
if(result == API_ERROR){
printf("\r\nTCP Echoserver, accept failed %d",error);
shutDownServer(lsd,error);
}//if(result == API_ERROR)
InetToAscii(&claddr.sin_addr.s_addr,ClientIP);
#ifdef TCPSERV_DEBUG
printf("\r\nTCP Echoserver: Connected with %s , Port %u\r\n",ClientIP,claddr.sin_port);
#endif
asd = result;
cnt_connection++;
#ifdef SERVER_SHUTDOWN_TEST
if(cnt_connection>6L){
result = closesocket(asd,&error);
if(result==API_ERROR){
printf("\r\nTCP Echoserver, socket close failed %d",error);
}
printf("\r\nTCP Echoserver: Shutdown test\r\n");
shutDownServer(lsd,error);
}//if(cnt_connection>6L)
#endif
/**
* Suche einer ruhenden Server Task
*/
taskrdy = Get_Free_Server_Task();
if(taskrdy == -1){ //no sleeping task found
#ifdef TCPSERV_DEBUG
printf("\r\nTCPserver: busy, refusing connection with %s , Port %u\r\n",ClientIP,claddr.sin_port);
#endif
closesocket(asd, &error);
}//if(taskrdy == -1)
else{
//insert the socket descriptor
EchoServer[taskrdy].sd = asd;
//and wakeup the sleeping server task
result = RTX_Wakeup(EchoServer[taskrdy].taskID);
if(result != 0){
printf("\r\nTCPserver: wakeup error\r\n");
closesocket(asd, &error);
}//if(result != 0)
else{
//a task is waked up and serves from now on this connection
}
}//elseif(taskrdy == -1) //no sleeping task found
}//while(1) //do forever
}
