Annotation of micropolis/src/sim/w_net.c, revision 1.1.1.1

1.1       root        1: /* w_net.c
                      2:  *
                      3:  * Micropolis, Unix Version.  This game was released for the Unix platform
                      4:  * in or about 1990 and has been modified for inclusion in the One Laptop
                      5:  * Per Child program.  Copyright (C) 1989 - 2007 Electronic Arts Inc.  If
                      6:  * you need assistance with this program, you may contact:
                      7:  *   http://wiki.laptop.org/go/Micropolis  or email  [email protected].
                      8:  * 
                      9:  * This program is free software: you can redistribute it and/or modify
                     10:  * it under the terms of the GNU General Public License as published by
                     11:  * the Free Software Foundation, either version 3 of the License, or (at
                     12:  * your option) any later version.
                     13:  * 
                     14:  * This program is distributed in the hope that it will be useful, but
                     15:  * WITHOUT ANY WARRANTY; without even the implied warranty of
                     16:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
                     17:  * General Public License for more details.  You should have received a
                     18:  * copy of the GNU General Public License along with this program.  If
                     19:  * not, see <http://www.gnu.org/licenses/>.
                     20:  * 
                     21:  *             ADDITIONAL TERMS per GNU GPL Section 7
                     22:  * 
                     23:  * No trademark or publicity rights are granted.  This license does NOT
                     24:  * give you any right, title or interest in the trademark SimCity or any
                     25:  * other Electronic Arts trademark.  You may not distribute any
                     26:  * modification of this program using the trademark SimCity or claim any
                     27:  * affliation or association with Electronic Arts Inc. or its employees.
                     28:  * 
                     29:  * Any propagation or conveyance of this program must include this
                     30:  * copyright notice and these terms.
                     31:  * 
                     32:  * If you convey this program (or any modifications of it) and assume
                     33:  * contractual liability for the program to recipients of it, you agree
                     34:  * to indemnify Electronic Arts for any liability that those contractual
                     35:  * assumptions impose on Electronic Arts.
                     36:  * 
                     37:  * You may not misrepresent the origins of this program; modified
                     38:  * versions of the program must be marked as such and not identified as
                     39:  * the original program.
                     40:  * 
                     41:  * This disclaimer supplements the one included in the General Public
                     42:  * License.  TO THE FULLEST EXTENT PERMISSIBLE UNDER APPLICABLE LAW, THIS
                     43:  * PROGRAM IS PROVIDED TO YOU "AS IS," WITH ALL FAULTS, WITHOUT WARRANTY
                     44:  * OF ANY KIND, AND YOUR USE IS AT YOUR SOLE RISK.  THE ENTIRE RISK OF
                     45:  * SATISFACTORY QUALITY AND PERFORMANCE RESIDES WITH YOU.  ELECTRONIC ARTS
                     46:  * DISCLAIMS ANY AND ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES,
                     47:  * INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, SATISFACTORY QUALITY,
                     48:  * FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY
                     49:  * RIGHTS, AND WARRANTIES (IF ANY) ARISING FROM A COURSE OF DEALING,
                     50:  * USAGE, OR TRADE PRACTICE.  ELECTRONIC ARTS DOES NOT WARRANT AGAINST
                     51:  * INTERFERENCE WITH YOUR ENJOYMENT OF THE PROGRAM; THAT THE PROGRAM WILL
                     52:  * MEET YOUR REQUIREMENTS; THAT OPERATION OF THE PROGRAM WILL BE
                     53:  * UNINTERRUPTED OR ERROR-FREE, OR THAT THE PROGRAM WILL BE COMPATIBLE
                     54:  * WITH THIRD PARTY SOFTWARE OR THAT ANY ERRORS IN THE PROGRAM WILL BE
                     55:  * CORRECTED.  NO ORAL OR WRITTEN ADVICE PROVIDED BY ELECTRONIC ARTS OR
                     56:  * ANY AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY.  SOME
                     57:  * JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF OR LIMITATIONS ON IMPLIED
                     58:  * WARRANTIES OR THE LIMITATIONS ON THE APPLICABLE STATUTORY RIGHTS OF A
                     59:  * CONSUMER, SO SOME OR ALL OF THE ABOVE EXCLUSIONS AND LIMITATIONS MAY
                     60:  * NOT APPLY TO YOU.
                     61:  */
                     62: #include "sim.h"
                     63: 
                     64: 
                     65: #ifdef NET
                     66: 
                     67: 
                     68: #define NET_BUFFER_SIZE 1024
                     69: 
                     70: 
                     71: int net_listen_port;
                     72: int net_listen_socket;
                     73: 
                     74: 
                     75: int
                     76: udp_listen(int port)
                     77: {
                     78:   struct sockaddr_in addr;
                     79:   int flags;
                     80: 
                     81:   net_listen_port = port;
                     82: 
                     83:   net_listen_socket = socket(AF_INET, SOCK_DGRAM, 0);
                     84:   if (net_listen_socket < 0) {
                     85:     perror("socket()");
                     86:     return 0;
                     87:   }
                     88: 
                     89:   flags = 1;
                     90:   if (setsockopt(net_listen_socket, SOL_SOCKET, SO_REUSEADDR,
                     91:                 (char *)&flags, sizeof(flags)) == -1) {
                     92:     perror("setsockopt SO_REUSEADDR");
                     93:     return 0;
                     94:   }
                     95: 
                     96:   addr.sin_family = AF_INET;
                     97:   addr.sin_port = net_listen_port;
                     98:   addr.sin_addr.s_addr = INADDR_ANY;
                     99: 
                    100:   if (bind(net_listen_socket, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
                    101:     perror("bind()");
                    102:     return 0;
                    103:   }
                    104: 
                    105:   if ((flags = fcntl(net_listen_socket, F_GETFL)) < 0) {
                    106:     perror("fcntl F_GETFL");
                    107:     return 0;
                    108:   }
                    109:   
                    110:   if (fcntl(net_listen_socket, F_SETFL, flags|O_NDELAY) < 0) {
                    111:     perror("fcntl F_SETFL");
                    112:     return 0;
                    113:   }
                    114: 
                    115:   Tcp_MakeOpenFile(tk_mainInterp, net_listen_socket, 1, 1);
                    116: 
                    117:   return (net_listen_socket);
                    118: }
                    119: 
                    120: 
                    121: udp_hear(int sock)
                    122: {
                    123:   struct sockaddr_in addr;
                    124:   int addr_len;
                    125:   int len, i;
                    126:   unsigned char buf[NET_BUFFER_SIZE];
                    127:   char cmd[NET_BUFFER_SIZE * 4 + 256];
                    128:   char *cp;
                    129: 
                    130:   while (1) {
                    131:     len = recvfrom(sock, buf, NET_BUFFER_SIZE, 0,
                    132:                   (struct sockaddr *)&addr, &addr_len);
                    133: 
                    134:     if (len < 0) {
                    135:       if (errno == EINTR) continue;
                    136:       if (errno == EWOULDBLOCK) break;
                    137:       perror("recvfrom");
                    138:       return;
                    139:     }
                    140: 
                    141:     sprintf(cmd, "HandlePacket %d {%s} {", sock, inet_ntoa(addr.sin_addr));
                    142: 
                    143:     cp = cmd + strlen(cmd);
                    144:     for (i = 0; i < len; i++) {
                    145:       sprintf(cp, "%3d ", buf[i]);
                    146:       cp += 4;
                    147:     }
                    148:     sprintf(cp, "}");
                    149:     Eval(cmd);
                    150:   }
                    151: }
                    152: 
                    153: 
                    154: #endif

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.