/* start a new listen server to get the list */
int ogc_init (char *localport, char *server, char *port, char *game, int ai_family) {
int i;
ogc_sock = -1;
ogc_sock = udp_server (localport, ai_family);
d_printf ("ogc_init (Localport: %s, Server %s:%s Game %s socket=%d)\n", localport, server, port, game, ogc_sock);
if (ogc_sock <= 0)
return 0;
strncpy (ogc_host, server, LEN_OGCHOST);
strncpy (ogc_port, port, LEN_OGCPORT);
strncpy (ogc_game, game, LEN_GAME);
ogc_ai_family = ai_family;
d_printf ("ogc_host:%s ogc_port:%s ogc_game:%s ogc_ai_family:%d\n", ogc_host, ogc_port, ogc_game, ogc_ai_family);
if (dns_filladdr (ogc_host, LEN_OGCHOST, ogc_port, LEN_OGCPORT, ogc_ai_family, &ogc_addr) < 0) {
udp_close (ogc_sock);
ogc_sock = -1;
return 0;
}
for (i = 0; i < MAX_OGC_ENTRYS; i++)
ogc_array[i].serial = -1;
return 1;
};
void
server_main()
{
char *buf = (char*)valloc(MAX_MSIZE);
int sock, sent, namelen, seq = 0;
struct sockaddr_in it;
GO_AWAY;
sock = udp_server(UDP_XACT, SOCKOPT_REUSE);
while (1) {
int nbytes;
namelen = sizeof(it);
if ((nbytes = recvfrom(sock, (void*)buf, MAX_MSIZE, 0,
(struct sockaddr*)&it, &namelen)) < 0) {
fprintf(stderr, "lat_udp server: recvfrom: got wrong size\n");
exit(9);
}
sent = ntohl(*(int*)buf);
if (sent < 0) {
udp_done(UDP_XACT);
exit(0);
}
if (sent != ++seq) {
seq = sent;
}
*(int*)buf = htonl(seq);
if (sendto(sock, (void*)buf, nbytes, 0,
(struct sockaddr*)&it, sizeof(it)) < 0) {
perror("lat_udp sendto");
exit(9);
}
}
}
void
server_main()
{
char *buf = (char*)valloc(MAX_MSIZE);
int sock, namelen, seq = 0;
long nbytes, msize;
struct sockaddr_in it;
GO_AWAY;
sock = udp_server(UDP_XACT, SOCKOPT_NONE);
while (1) {
namelen = sizeof(it);
if (recvfrom(sock, (void*)buf, 2 * sizeof(long), 0,
(struct sockaddr*)&it, &namelen) < 0) {
fprintf(stderr, "bw_udp server: recvfrom: got wrong size\n");
exit(9);
}
nbytes = ntohl(*(long*)buf);
msize = ntohl(*((long*)buf + 1));
while (nbytes > 0) {
if (sendto(sock, (void*)buf, msize, 0,
(struct sockaddr*)&it, sizeof(it)) < 0) {
perror("bw_udp sendto");
exit(9);
}
nbytes -= msize;
}
}
}
int main(int argc, const char *argv[])
{
fb_info fb_v;
fb_info * temp;
pthread_t id;
int ret;
Dot mid;
mid.x = 512;
mid.y = 275;
char ip_address[20];
int mode;
create_fb(&fb_v);
system("clear");
mode = startup(fb_v, ip_address);
draw_pic(fb_v,OFFSET - 20,0,940,720,gImage_chessboard);
draw_pic(fb_v,OFFSET - 120,200,100,100,gImage_chessboard);
draw_pic(fb_v,OFFSET - 120,500,100,100,gImage_chessboard);
draw_piece(fb_v,OFFSET - 70,250,40,0x00000000);
draw_piece(fb_v,OFFSET - 70,550,40,0xffffffff);
print_board(fb_v,23,30,30,OFFSET,15,0x00000000);
temp = &fb_v;
if((ret = pthread_create(&id, NULL, (void *) mouse_test,(void *)temp)) != 0)
{
printf("Create pthread error!\n");
exit(1);
}
if(mode == 1)
udp_server(fb_v);
else
udp_client(fb_v, ip_address);
return 0;
}
int main()
{
int sock, port, len;
char buf[2048];
if (udp_server(&sock, &port) != 0) {
perror("udp_server");
return 1;
}
(void) printf("UDP server port=%d\n",port);
while ((len = udp_recv(sock, buf, 2048)) >= 0) {
(void) printf("UDP server: len=%d, data='%s'\n", len, buf);
if (strcmp(buf, "exit") == 0) {
(void) close(sock);
return 0;
}
}
perror("recvfrom failed");
(void) printf("UDP server: error from udp_recv, len=%d\n",len);
(void) close(sock);
return 1;
}
int main(int argc,char *argv[])
{
if(argc != 5)
{
printf("Incorrect format\n");
printf("\n Usage: %s <listenportno> <ip of server> <connectportno> <protocol>\n",argv[0]);
return 1;
}
char *listenportno = argv[1];
char *connectportno = argv[3];
char *ip = argv[2];
if(strcmp(argv[3],"udp")==0)
isudpset = 1;
else
isudpset = 0;
pid_t pid;
pid = fork();
if(pid == 0)
{
if(isudpset)
udp_server(listenportno);
else
tcp_server(listenportno);
}
else if(pid > 0)
{
if(isudpset)
udp_client(ip,connectportno);
else
tcp_client(ip,connectportno);
}
return 0;
}
int
main(int argc, char** argv)
{
long status;
int sockFD;
struct sockaddr_in localAddr;
if (argc < 2) {
printf("usage: %s <local-port>\n", argv[0]);
exit(5);
}
sockFD = socket(AF_INET, SOCK_DGRAM, 0);
memset(&localAddr, 0, sizeof(struct sockaddr_in));
localAddr.sin_family = AF_INET;
localAddr.sin_port = htons(atoi(argv[1]));
printf("binding to port %u\n", ntohs(localAddr.sin_port));
status = bind(sockFD, (struct sockaddr *)&localAddr, sizeof(struct sockaddr_in));
if (status < 0) {
printf("bind(): %lx (%s)\n", status, strerror(status));
exit(5);
}
udp_server(sockFD);
return 0;
}
int main(void)
{
puts("IETF90 - BnB - CCN-RPL router");
/*
if (msg_init_queue(msg_buffer_shell, SHELL_MSG_BUFFER_SIZE) != 0) {
DEBUG("msg init queue failed...abording\n");
return -1;
}
*/
riot_ccn_relay_start();
id = 2;
/* fill neighbor cache */
fill_nc();
riot_ccn_appserver(1, NULL);
rpl_ex_init('n');
udp_server(1, NULL);
posix_open(uart0_handler_pid, 0);
net_if_set_src_address_mode(0, NET_IF_TRANS_ADDR_M_SHORT);
shell_init(&shell, sc, UART0_BUFSIZE, uart0_readc, uart0_putc);
shell_run(&shell);
return 0;
}
int main(int argc, char* argv[]) {
int sockfd;
ssize_t n;
socklen_t len;
time_t ticks;
char buf[BUF_SIZE];
char ip[BUF_SIZE];
struct sockaddr_storage cliaddr;
struct sockaddr *sa;
struct sockaddr_in* sin;
struct sockaddr_in6* sin6;
if (2 == argc) {
sockfd = udp_server(NULL, argv[1], NULL);
} else if (3 == argc) {
sockfd = udp_server(argv[1], argv[2], NULL);
} else {
printf("USAGE: %s [host/IP] <service/port>\n", argv[0]);
exit(EXIT_FAILURE);
}
while (1) {
len = sizeof(cliaddr);
n = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr*)&cliaddr, &len);
buf[n] = '\0';
sa = (struct sockaddr*)&cliaddr;
switch (sa->sa_family) {
case AF_INET:
sin = (struct sockaddr_in*)&cliaddr;
printf("[IPv4] datagram from %s\n", inet_ntop(AF_INET, &(sin->sin_addr), ip, sizeof(ip)));
break;
case AF_INET6:
sin6 = (struct sockaddr_in6*)&cliaddr;
printf("[IPv6] datagram from %s\n", inet_ntop(AF_INET6, &(sin6->sin6_addr), ip, sizeof(ip)));
break;
default:
printf("unknown type.\n");
break;
}
ticks = time(NULL);
snprintf(buf, sizeof(buf), "%.24s\n", ctime(&ticks));
sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr*)&cliaddr, len);
}
}
int main(int argc, char **argv) {
ros::init(argc, argv, "udp_server");
ros::NodeHandle node_handle;
hector_serialization::udp_server udp_server(node_handle);
if (!udp_server.init()) return 1;
ros::spin();
return 0;
}
int
Udp_server(const char *host, const char *serv, socklen_t *addrlenp)
{
int n;
if ( (n = udp_server(host, serv, addrlenp)) < 0)
err_quit("udp_server error for %s, %s", host, serv);
return(n);
}
/** Server test program */
int server(unsigned int port)
{
/* init result to failure */
int result = TEST_FAIL;
/* start udp server */
if(udp_server((uint16_t)port, server_startup_callback, NULL, server_callback, (void *)(&result), (uint_fast8_t)0))
return_val_flail(TEST_FAIL, ";;rp udp server returned error");
/* return result from callbacks */
return result;
}
int main(void)
{
int server_fd;
char buf[128];
struct sockaddr client;
socklen_t client_len = sizeof(struct sockaddr);
server_fd = udp_server("127.0.0.1", "21114");
udp_recvfrom(server_fd, buf, sizeof(buf), &client, &client_len);
strcat(buf, " from server");
udp_sendto(server_fd, buf, sizeof(buf), &client, client_len);
udp_close(server_fd);
}
/*
setup everything for the network loop
*/
int
network_init ()
{
char host[LEN_SERVERNAME];
char port[LEN_PORT];
/* we need it for the windows winsock */
#ifdef _WIN32
WSADATA wsaData;
if (WSAStartup (MAKEWORD (1, 1), &wsaData) != 0) {
d_printf ("WSAStartup failed.\n");
exit (1);
}
#endif
if (bman.net_ai_family == PF_INET)
sprintf (host, "IPv4");
#ifndef _WIN32
else if (bman.net_ai_family == PF_INET6)
sprintf (host, "IPv6");
#endif
else
sprintf (host, "IPv (unknown)");
d_printf ("Network Init with %s.\n", host);
bman.sock = -1;
timestamp = SDL_GetTicks ();
// start the udp server
bman.sock = udp_server (bman.port, bman.net_ai_family);
if (bman.sock < 0) {
#ifdef _WIN32
WSACleanup ();
#endif
return -1;
}
if (bman.notifygamemaster) {
network_server_port (bman.ogcserver, host, LEN_SERVERNAME, port, LEN_PORT);
if (ogc_init (bman.ogc_port, host, port, "BomberClone", bman.net_ai_family) == 0)
bman.notifygamemaster = 0;
}
// we have got our socket..
rscache_init ();
return 0;
};
int main()
{
pid_t pid;
pid = fork();
if (pid == 0) {
tcp_server();
} else {
udp_server();
}
return 0;
}
/*************************************************************************
* \brief main
*************************************************************************/
int main(int argc, char* argv[])
{
pid_t pid;
pid = fork();
if (pid == 0)
{
tcp_server();
}
else
{
udp_server();
}
return 0;
}
int main(void)
{
char *args[2];
char *cmd = "udp_server";
char *port = "8888";
args[0] = cmd;
args[1] = port;
msg_init_queue(_main_msg_queue, MAIN_QUEUE_SIZE);
udp_server(2, args);
thread_create(_stack, sizeof(_stack), THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
_send, NULL, "send");
char line_buf[SHELL_DEFAULT_BUFSIZE];
shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE);
return 0;
}
static int udprecv(void){
socklen_t sa_len;
int sfd = -1;
int status = 0;
int gai_code;
sfd = udp_server(g.host, g.service, &sa_len, &gai_code);
if(sfd < 0){
if(gai_code == 0)
err(1, "Error in udp_server()");
else
errx(1, "Error in gataddrinfo() in udp_server(). %s",
gai_strerror(gai_code));
return(-1);
}
status = loop(sfd, sa_len); /* receive and print */
return(status);
}
int main(int argc, char *argv[]) {
char proto, mode;
unsigned int addr;
unsigned short port;
//read arguments (options)
readargs(argc, argv, &proto, &mode, &addr, &port, "10001");
if(mode == 's') {
if(proto == 'u') {
udp_server(port);
} else {
tcp_server(port);
}
} else {
if(proto == 'u') {
udp_client(addr, port, 0);
} else {
tcp_client(addr, port, 0);
}
}
return 0;
}
int main(int argc, char **argv)
{
struct sockaddr_in peer;
char *hostname;
char *servicename;
int peerlen;
socket_t client_socket;
socket_t server_socket;
const int on = 1;
char type;
if (argc == 3) {
hostname = NULL;
servicename = argv[1];
type = argv[2][0];
} else if (argc == 4) {
hostname = argv[1];
servicename = argv[2];
type = argv[3][0];
} else {
error(1, errno, "count of parametrs mismatch\n");
}
if(type != 't' && type != 'u')
{
error(1, errno, "Parametr is wrong. Must 't' or 'u'.\n");
}
if(type == 'u')
{
do {
memset(&peer,0x00,sizeof(peer));
server_socket = udp_server(hostname, servicename);
peerlen = sizeof(peer);
peerlen = sizeof(peer);
recvfrom(server_socket, NULL, 1, 0,
(struct sockaddr *)&peer,&peerlen);
if(connect(server_socket, (struct sockaddr *)&peer, peerlen))
error( 1, errno, "error function connect\n");
udp_server_handler(server_socket, &peer);
close_socket(server_socket);
} while (1);
}
if(type == 't')
{
server_socket = tcp_server(hostname, servicename);
do {
peerlen = sizeof(peer);
client_socket =
accept(server_socket, (struct sockaddr *) &peer, &peerlen);
if (client_socket < 0)
error(1, errno, "error function accept\n");
switch(fork())
{
case 0:
close_socket(server_socket);
tcp_server_handler(client_socket, &peer);
exit(0);
case -1:
exit(-1);
default:
close_socket(client_socket);
}
} while (1);
close_socket(server_socket);
}
exit(0);
}
/*
* Main function
*/
int main(int argc, char** argv) {
struct timeval t_out;
int i, iflag, hflag, nflag, pflag;
server_stat status;
char *port;
char usage[100];
snprintf(usage, 100, "Usage: %s -i <robot_id> -n <robot-name> -h <http_hostname> -p <udp_port>", argv[0]);
status.r_stat.hostname[0] = '\0';
if (argc != 9) {
fprintf(stderr, "%s\n", usage);
return -1;
}
// read in the required arguments
iflag = hflag = pflag = 0;
for (i = 1; i < argc; i+=2) {
if (strcmp(argv[i], "-n") == 0) {
status.r_stat.id = atoi(argv[i + 1]);
iflag = 1;
} else if (strcmp(argv[i], "-h") == 0) {
strncpy(status.r_stat.hostname, argv[i + 1], BUFFER_LEN - 1);
hflag = 1;
} else if (strcmp(argv[i], "-p") == 0) {
port = argv[i + 1];
pflag = 1;
} else if (strcmp(argv[i], "-i") == 0) {
status.r_stat.name = argv[i + 1];
nflag = 1;
}else {
fprintf(stderr, "%s\n", usage);
return -1;
}
}
if (!(iflag && hflag && nflag && pflag)) {
fprintf(stderr, "%s\n", usage);
return -1;
}
// set up the udp socket
status.udp_sock = udp_server(port);
// timeouts
t_out.tv_sec = 60;
t_out.tv_usec = 0;
timeout_setup(status.udp_sock, t_out);
// execution loop
srand(time(NULL));
status.size = sizeof(status.cliaddr);
status.password = rand() + 1;
status.connected = 0;
buffer* recv_buf = create_buffer(BUFFER_LEN);
for (;;) {
timeout_setup(status.udp_sock, t_out);
unsigned char temp[BUFFER_LEN];
memset(temp, '\0', BUFFER_LEN);
int f = 10000;
if ((f = recvfrom(status.udp_sock, temp, BUFFER_LEN, 0,
(struct sockaddr *)(&status.cliaddr), &status.size)) < 0) {
if (status.connected != 0) {
buffer* quit_buf = create_message(0, status.password, QUIT, 0, 0, 0, 0);
quit(quit_buf, &status);
fprintf(stdout, "Waiting for a connection\n");
}
} else {
// decipher message
clear_buffer(recv_buf);
append_buffer(recv_buf, temp, f);
header msg_header = extract_header(recv_buf);
fprintf(stdout, "\nMessage received\n");
fprintf(stdout, "\tMessage size: %d\n", f);
// send to correct protocol
void (*protocol_func)(buffer*, server_stat*);
protocol_func = check_version(&msg_header) ? &protocol1:&protocol2;
protocol_func(recv_buf, &status);
}
if (status.connected != 0) {
fprintf(stdout, "Waiting for a message\n");
}
fflush(stdout);
fflush(stderr);
}
return 0;
}
int main( void )
{
std::cout << "¡¡¡Start Masteroids server!!!" << std::endl; // prints !!!UDP server!!!
/*
* Variables
*/
std::clock_t last_time = clock();
std::clock_t last_frame = clock();
float t_delta = 0;
float animate = 0.0;
int frames_per_second = 0;
int last_frames_per_second = 0;
float time_step = 1.0 / 160.0;
int velocity_iterator = 6;
int position_iterator = 2;
int number_of_inital_asteroids = 200;
/*
* Configure UPD server
*/
int server_port = MASTEROIDS_SERVER_PORT;
const std::string server_addres = MASTEROIDS_SERVER_IP;
udp_server masteroids_server = udp_server(server_addres, server_port);
/*
* Configure lists: clients, asteroids
*/
// List of Clients
std::list< Client > client_list();
// list with numberOfInitialAsteroids default build
std::list< Asteroids > asteroid_list();
// world conditions
b2Vec2 gravity = b2Vec2( 0.0, 0.0 );
b2ContactFilter* contacListener = new b2ContactFilter();
MasteroidsDestructorListerner* destructorListener = new MasteroidsDestructorListerner();
b2World world = b2World( gravity );
world.SetContactFilter( contacListener );
world.SetDestructionListener( destructorListener );
for ( int asteroid_it = 0; asteroid_it << number_of_inital_asteroids ; asteroid_it++ )
{
Asteroids new_asteroid = Asteroids( );
asteroid_list().push_back( new_asteroid );
}
return ( 0 );
}
void
udp_server_init(const char *addr, int port)
{
struct udp_server *u = udp_server(addr, port);
nanny_register_server(udp_server_message, u->sock, u);
}
int
Udp_server(const char *host, const char *serv, socklen_t *addrlenp)
{
return(udp_server(host, serv, addrlenp));
}
