apps/plugins/pdbox/pdbox-net.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2009 Wincent Balin
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "plugin.h"
  23 #include "pdbox.h"
  24
  25 /* Datagram pool will contains 16 datagrams. */
  26 #define MAX_DATAGRAMS 16
  27
  28 /* Datagram pool. */
  29 struct datagram datagrams[MAX_DATAGRAMS];
  30
  31 /* UDP message queues. */
  32 struct event_queue gui_to_core;
  33 struct event_queue core_to_gui;
  34
  35 /* Initialize net infrastructure. */
  36 void net_init(void)
  37 {
  38     unsigned int i;
  39
  40     /* Initialize message pool. */
  41     for(i = 0; i < MAX_DATAGRAMS; i++)
  42         datagrams[i].used = false;
  43
  44     /* Initialize and register message queues. */
  45     rb->queue_init(&gui_to_core, true);
  46     rb->queue_init(&core_to_gui, true);
  47 }
  48
  49 /* Send datagram. */
  50 bool send_datagram(struct event_queue* route,
  51                    int port,
  52                    char* data,
  53                    size_t size)
  54 {
  55     unsigned int i;
  56
  57     /* If datagram too long, abort. */
  58     if(size > MAX_DATAGRAM_SIZE)
  59         return false;
  60
  61     /* Find free datagram buffer. */
  62     for(i = 0; i < MAX_DATAGRAMS; i++)
  63         if(!datagrams[i].used)
  64             break;
  65
  66     /* If no free buffer found, abort. */
  67     if(i == MAX_DATAGRAMS)
  68         return false;
  69
  70     /* Copy datagram to the buffer. */
  71     memcpy(datagrams[i].data, data, size);
  72     datagrams[i].size = size;
  73
  74     /* Mark datagram buffer as used. */
  75     datagrams[i].used = true;
  76
  77     /* Send event via route. */
  78     rb->queue_post(route, port, (intptr_t) &datagrams[i]);
  79
  80     /* Everything went ok. */
  81     return true;
  82 }
  83
  84 /* Receive datagram. */
  85 bool receive_datagram(struct event_queue* route,
  86                       int port,
  87                       struct datagram* buffer)
  88 {
  89     struct queue_event event;
  90
  91     /* If route queue empty, abort. */
  92     if(rb->queue_empty(route))
  93         return false;
  94
  95     /* Receive event. */
  96     rb->queue_wait(route, &event);
  97
  98     /* If wrong port, abort.
  99        NOTE: Event is removed from the queue in any case! */
 100     if(event.id != port)
 101         return false;
 102
 103     /* Copy datagram. */
 104     memcpy(buffer, (struct datagram*) event.data, sizeof(struct datagram));
 105
 106     /* Clear datagram event. */
 107     memset(((struct datagram*) event.data)->data,
 108            0,
 109            ((struct datagram*) event.data)->size);
 110
 111     /* Free datagram event. */
 112     ((struct datagram*) event.data)->used = false;
 113
 114     /* Everything went ok. */
 115     return true;
 116 }
 117
 118 /* Destroy net infrastructure. */
 119 void net_destroy(void)
 120 {
 121     /* Remove message queues. */
 122     rb->queue_delete(&gui_to_core);
 123     rb->queue_delete(&core_to_gui);
 124 }
 125