Return to enet_slirp.c CVS log

Up to [Previous NeXT emulator] / previous / src

Annotation of previous/src/enet_slirp.c, revision 1.1

1.1     ! root        1: #include "m68000.h"
        !             2: #include "ethernet.h"
        !             3: #include "enet_slirp.h"
        !             4: #include "queue.h"
        !             5: 
        !             6: #include <SDL.h>
        !             7: #ifndef _WIN32
        !             8: #include <signal.h>
        !             9: #endif
        !            10: 
        !            11: 
        !            12: /****************/
        !            13: /* -- SLIRP -- */
        !            14: 
        !            15: #include <arpa/inet.h>
        !            16: 
        !            17: /* slirp prototypes */
        !            18: extern  int slirp_init(void);
        !            19: int slirp_redir(int is_udp, int host_port, struct in_addr guest_addr, int guest_port);
        !            20: extern  void slirp_input(const uint8_t *pkt, int pkt_len);
        !            21: extern  int slirp_select_fill(int *pnfds,
        !            22:                               fd_set *readfds, fd_set *writefds, fd_set *xfds);
        !            23: extern  void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds);
        !            24: extern  void slirp_exit(int);
        !            25: void slirp_debug_init(char*,int);
        !            26: extern  void slirp_output(const unsigned char *pkt, int pkt_len);
        !            27: extern  int slirp_can_output(void);
        !            28: 
        !            29: /* queue prototypes */
        !            30: queueADT       slirpq;
        !            31: 
        !            32: int slirp_inited;
        !            33: static SDL_mutex *slirp_mutex = NULL;
        !            34: SDL_Thread *tick_func_handle;
        !            35: 
        !            36: //Is slirp initalized?
        !            37: //Is set to true from the init, and false on ethernet disconnect
        !            38: int slirp_can_output(void)
        !            39: {
        !            40:     return slirp_inited;
        !            41: }
        !            42: 
        !            43: //This is a callback function for SLiRP that sends a packet
        !            44: //to the calling library.  In this case I stuff
        !            45: //it in q queue
        !            46: void slirp_output (const unsigned char *pkt, int pkt_len)
        !            47: {
        !            48:     struct queuepacket *p;
        !            49:     p=(struct queuepacket *)malloc(sizeof(struct queuepacket));
        !            50:     SDL_LockMutex(slirp_mutex);
        !            51:     p->len=pkt_len;
        !            52:     memcpy(p->data,pkt,pkt_len);
        !            53:     QueueEnter(slirpq,p);
        !            54:     SDL_UnlockMutex(slirp_mutex);
        !            55:     Log_Printf(LOG_WARN, "[SLIRP] Output packet with %i bytes to queue",pkt_len);
        !            56: }
        !            57: 
        !            58: //This function is to be periodically called
        !            59: //to keep the internal packet state flowing.
        !            60: void slirp_tick(void)
        !            61: {
        !            62:     int ret2,nfds;
        !            63:     struct timeval tv;
        !            64:     fd_set rfds, wfds, xfds;
        !            65:     int timeout;
        !            66:     nfds=-1;
        !            67:     
        !            68:     if (slirp_inited)
        !            69:     {
        !            70:         FD_ZERO(&rfds);
        !            71:         FD_ZERO(&wfds);
        !            72:         FD_ZERO(&xfds);
        !            73:         timeout=slirp_select_fill(&nfds,&rfds,&wfds,&xfds); //this can crash
        !            74:         
        !            75:         if(timeout<0)
        !            76:             timeout=500;
        !            77:         tv.tv_sec=0;
        !            78:         tv.tv_usec = timeout;    //basilisk default 10000
        !            79:         
        !            80:         ret2 = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
        !            81:         if(ret2>=0){
        !            82:             SDL_LockMutex(slirp_mutex);
        !            83:             slirp_select_poll(&rfds, &wfds, &xfds);
        !            84:             SDL_UnlockMutex(slirp_mutex);
        !            85:         }
        !            86:     }
        !            87: }
        !            88: 
        !            89: static int tick_func(void *arg)
        !            90: {
        !            91:     while(slirp_inited)
        !            92:     {
        !            93:         SDL_Delay(10);
        !            94:         slirp_tick();
        !            95:     }
        !            96:     return 0;
        !            97: }
        !            98: 
        !            99: 
        !           100: void enet_slirp_queue_poll(void)
        !           101: {
        !           102:     SDL_LockMutex(slirp_mutex);
        !           103:     if (QueuePeek(slirpq)>0)
        !           104:     {
        !           105:         struct queuepacket *qp;
        !           106:         qp=QueueDelete(slirpq);
        !           107:         Log_Printf(LOG_WARN, "[SLIRP] Getting packet from queue");
        !           108:         enet_receive(qp->data,qp->len);
        !           109:         free(qp);
        !           110:     }
        !           111:     SDL_UnlockMutex(slirp_mutex);
        !           112: }
        !           113: 
        !           114: void enet_slirp_input(Uint8 *pkt, int pkt_len) {
        !           115:     if (slirp_inited) {
        !           116:         Log_Printf(LOG_WARN, "[SLIRP] Input packet with %i bytes",enet_tx_buffer.size);
        !           117:         SDL_LockMutex(slirp_mutex);
        !           118:         slirp_input(pkt,pkt_len);
        !           119:         SDL_UnlockMutex(slirp_mutex);
        !           120:     }
        !           121: }
        !           122: 
        !           123: void enet_slirp_stop(void) {
        !           124:     int ret;
        !           125:     
        !           126:     if(slirp_inited) {
        !           127:         Log_Printf(LOG_WARN, "Stopping SLIRP");
        !           128:         slirp_inited=0;
        !           129:         //slirp_exit(0);
        !           130:         QueueDestroy(slirpq);
        !           131:         SDL_DestroyMutex(slirp_mutex);
        !           132:         SDL_WaitThread(tick_func_handle, &ret);
        !           133:     }
        !           134: }
        !           135: 
        !           136: void enet_slirp_start(void) {
        !           137:     struct in_addr guest_addr;
        !           138:     
        !           139:     if (!slirp_inited) {
        !           140:         Log_Printf(LOG_WARN, "Starting SLIRP");
        !           141: #ifndef _WIN32
        !           142:         signal(SIGPIPE, SIG_IGN);
        !           143: #endif
        !           144:         slirp_init();
        !           145:         slirpq = QueueCreate();
        !           146:         slirp_inited=1;
        !           147:         //SDL_Delay(500);
        !           148:         slirp_mutex=SDL_CreateMutex();
        !           149:         tick_func_handle=SDL_CreateThread(tick_func,"SLiRPTickThread", (void *)NULL);
        !           150:         inet_aton("10.0.2.15", &guest_addr);
        !           151:         slirp_redir(0, 42323, guest_addr, 23);
        !           152:     }
        !           153: }

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