---

gtcspeaker.h

Go to the documentation of this file.

/*
    Sebastien Loisel's Toolchest
    Copyright (C) 1998 Sebastien Loisel

    $Header: /home/gtc/public_html/gtc-cvs/toolchest/include/gtcspeaker.h,v 1.31 2001/07/09 05:53:43 loisel Exp $
    */

#ifndef Z_SPEAKER_H
#define Z_SPEAKER_H

#include <gtcutils.h>
#include <unistd.h>
#include <sys/types.h>

extern int gtcSpeakerverbose;

typedef unsigned char gtcByte;

typedef struct
{
  gtcByte *data;
  int 
  size,
    refcount;
  /* you may use the refcount if you want but it's mostly for sharing packets
     to write amongst multiple speakers. */
} gtcPacket;

typedef struct _gtcPacketList gtcPacketList;
struct _gtcPacketList
{
  gtcPacket *p;
  gtcPacketList *next;
};

typedef struct
{
  int fd;
  int dead;

  gtcPacketList *outhead, *outtail, *inhead, *intail;
  int rstate, rpos, wstate, wpos;
  unsigned char rfoo[4];
  gtcPacket *r; /* for holding half constructed received gtcPackets */
} gtcSpeaker;
  
/*****
 * Speaker stuff.
 *
 * The speaker is the basic network object. It does all the necessary grunt
 * work to send packets over the wire. Networking code is prone to bugs so
 * having this worked out is useful. Typically, you would get a speaker by
 * calling gtc_connect_2_host(...). Then you enter a select() loop where at
 * each step you do gtc_speaker_fds(...), call gtc_speaker_read() and
 * gtc_speaker_write() if the appropriate fd is set and then use
 * gtc_speaker_get() and gtc_speaker_put() to read and write to the net
 * respectively. When writing to the net, gtc_make_packet() will be useful
 * in creating packets. gtc_make_packet() creates packets by COPYING the
 * data. gtc_speaker_destroy() can be used to destroy a speaker. This also
 * has the effect of closing its fd.
 *****/

void gtc_set_non_block(int filedes);
gtcSpeaker *gtc_connect_2_host(char *host, int port);
gtcSpeaker *gtc_connect_2_fd(int fd);
void gtc_speaker_destroy(gtcSpeaker *foo);

void gtc_speaker_read(gtcSpeaker *s);
void gtc_speaker_write(gtcSpeaker *s);
int gtc_speaker_long_out_queue(gtcSpeaker *s);
gtcPacket *gtc_speaker_get(gtcSpeaker *s);
void gtc_speaker_put(gtcSpeaker *s, gtcPacket *p); /* send a packet */
gtcPacket *gtc_alloc_packet(int size);
gtcPacket *gtc_make_packet(gtcByte *data, int size);
void gtc_destroy_packet(gtcPacket *p);
void gtc_upcount_packet(gtcPacket *p);
void gtc_downcount_packet(gtcPacket *p);
void gtc_speaker_fds(gtcSpeaker *s, fd_set *readfds, fd_set *writefds);
void gtc_print_packet(gtcPacket *p);

/*****
 * Host stuff.
 *
 * This here does the basic work you need for a server. You would typically
 * use gtc_new_host() to get a host. Then you would enter a select() loop.
 * You gtc_host_fds() to set the fd_sets and then you select() and then you
 * gtc_host_process() to process all the fds related to the host. You may
 * also register callbacks in the gtcHost structure for when clients are
 * added and removed, or when they receive or send data.
 *****/

typedef struct _gtcSpeakerNode gtcSpeakerNode;
struct _gtcSpeakerNode
{
  gtcSpeaker *s;
  gtcSpeakerNode *next;
  void *userdata;
  void (*destructor)(gtcSpeakerNode *me);
  int refcount;
};

typedef struct _gtcHost gtcHost;
struct _gtcHost
{
  gtcSpeakerNode *first, *last; /* list of speakers */
  int
  lfd,
    bigfds; /* listen filedes & biggest filedes */
  int verbose; /* verbosity level (0, 1, 2 or 3) */

  void *userdata;
  void (*addcb)(gtcHost *h, gtcSpeakerNode *s);
  void (*delcb)(gtcHost *h, gtcSpeakerNode *s);
};

gtcHost *gtc_new_host_by_fd(int fd, int verbose);
gtcHost *gtc_new_host(int port, int verbose);
void gtc_host_fds(gtcHost *h, fd_set *readfds, fd_set *writefds);
void gtc_host_process(gtcHost *h, fd_set *readfds, fd_set *writefds);
void gtc_kill_host(gtcHost *h);
void gtc_speaker_node_destroy(gtcSpeakerNode *node);  


typedef struct _gtcClient gtcClient;
struct _gtcClient
{
  double sec_per_byte;
  double sec_next_send;
  gtcSpeaker *s;
  void *prev;
  int refcount;
};

enum gtcServerMessages
{
  gtcNewClient=0,
  gtcDeadClient=1,
  gtcReceivedPacket=2,
  gtcReadyForSending=3,
  gtcTimeout=4,

  gtcNoMessage
};

typedef struct _gtcServerMessage gtcServerMessage;
struct _gtcServerMessage
{
  gtcServerMessage *next;
  int t;
  int client;
  int packet[5];
};

typedef struct
{
  gtcServerMessage mfirst;
  gtcServerMessage *mlast;
#if 0

  gtcClient cfirst;
  gtcClient *clast;
#endif
  gtcClient **clients;
  int client_count;
  int *client_free_list;
  int client_free_first;
  double default_sec_per_byte;
  int sizeofclient;
  int lfd;
  int verbose;
  int refcount;
} gtcServer;

gtcServer *gtc_server_new(int port, int verbose,
                          int sizeofclient, double sec_per_byte);
void gtc_server_delete(gtcServer *s);
gtcServerMessage *gtc_server_get_message(gtcServer *s, double timeout);
void gtc_server_next_message(gtcServer *s, double timeout,
                             gtcServerMessage *msg);
void gtc_client_put(gtcClient *c, gtcPacket *p);
void gtc_client_delete(gtcClient *c);

enum gtcClientMessages
{
  gtcKeyRepeat=0,
  gtcKeyPress,
  gtcKeyRelease,
  gtcConfigureNotify,
  gtcButtonPress,
  gtcButtonRelease,

  gtcNOP
};
#endif
 

---