---

Net.c

Go to the documentation of this file.

/*
 *    gui - [gega user interface] the flexible solution for user interface problems
 *    Copyright (C) 2002  Gergely Gati
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; version 2 of the License.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *    Gergely Gati
 *      email:           g.gati@freemail.hu
 *      AIM screenname:  GatiGergely
 *      ICQ number:      93131690
 *
 */
#include <stdlib.h>
#include <string.h>
#include <zlib.h>

#include "Gadget.h"
#include "debug.h"
#include "Memory.h"
#include "Net.h"
#include "NetCommon.h"
#include "Window.h"
#include "Module.h"
#include "Common.h"


struct net_File
{
  u8 *data;
  int size;
  u32 realsize;
  u32 type;
};


struct net_Files
{
  int file_count;
  int readed;
  u8 *next_data;
  u32 data_size;
  u8 *data;
};


struct net_FileCache
{
  u8 *data;
  int size;
  char *name;
  u32 crc;
  int expire;
  int check_interval;
  int last_checked;
};


//Declare call_vector[]
static u32 (*call_vector[NET_FUNC_DONE-NET_FUNCBASE+1])(tag *);



static u32 net_GetServerId(void)
{
  static u32 curr_id=1;

  debug_Begin();

  curr_id+=2;

  debug_End();

  return(curr_id);
}


void net_SerSendApp(u32 conn)
{
  struct glw_ConnUser *cuser=(struct glw_ConnUser *)conn;
  u32 m;

  debug_Begin();

  m=glw_htonl((u32)cuser->app);
  glw_SendMsg(conn,REQ_SAPP,net_GetServerId(),(u8 *)&m,4);

  debug_End();
}


int net_Server(u32 conn)
{
  struct glw_ConnUser *cuser=(struct glw_ConnUser *)conn;
  Node_t *node;
  struct net_FileCache *fcache;

  debug_Begin();

  if(NULL!=(cuser->waitlist=list_CreateList()))
  {
    if(NULL!=(cuser->file_cache=list_CreateList()))
    {
      gui_ServerMain(conn);
      while(NULL!=(node=list_RemoveNodeHead(cuser->file_cache)))
      {
        if(NULL!=(fcache=(struct net_FileCache *)list_GetNodeData(node)))
        {
          if(fcache->data!=NULL) mem_free(fcache->data);
          if(fcache->name!=NULL) mem_free(fcache->name);
          mem_free(fcache);
        }
        list_DeleteNode(node);
      }
      list_DeleteList(cuser->file_cache);
      cuser->file_cache=NULL;
    }
    net_ClearMsgList(conn);
  }

  debug_End();

  return(0);
}


/*
  kliens jelentkezese:
    ?GUI      - fix string (4 char)
    L/B       - little/bigendian (1 char)
    v1.0      - protokoll verzio (max 8 char)
    app-name  - app name (max 128 char)
  elvalaszto space-k 3 char
  max bejelentkezo uzenet-hossz: 144 char + zaro \0
  min hossz: 12 + appname (min 1 char) -> 13
 */
#define MAX_INIT_LEN  256

char *net_CheckClient(u32 conn, int *byteorder)
{
  int ln;
  char buff[MAX_INIT_LEN+1];
  char *v,*n,*name=NULL;
  int vmajor=0,vminor=0;

  debug_Begin();

  if(12<(ln=glw_Recv(conn,buff,MAX_INIT_LEN)))
  {
    buff[ln]='\0';
    if(strncmp(buff,"?GUI",4)==0)
    {
      if(buff[5]=='L') *byteorder=0;
      else *byteorder=1;
      v=&buff[7];
      n=strchr(v,' ');
      if(n!=NULL)
      {
        *n++='\0';
        sscanf(v,"v%d.%d",&vmajor,&vminor);
        if(vmajor==1&&vminor==1)
        {
          if(NULL!=(name=common_strdup(n)))
          {
            glw_Send(conn,"OK L " ARCH,7);
          }
        }
        else debug_Warning("Incompatible client version V%d.%d\n",vmajor,vminor);
      }
    }
  }
  if(name==NULL) glw_Send(conn,"ER",2);

  debug_End();

  return(name);
}


int net_ServerWindowEventHandler(gui_App_t *app, Window_t *win, u32 gadget_id, int event, u32 event_data)
{
  u8 msg[5*4];
  u8 *m=msg;
  u32 id;

  debug_Begin();

  m=net_MarshalPutLong(m,(u32)app);
  m=net_MarshalPutLong(m,(u32)win);
  m=net_MarshalPutLong(m,(u32)gadget_id);
  m=net_MarshalPutLong(m,(u32)event);
  m=net_MarshalPutLong(m,(u32)event_data);
  id=net_GetServerId();
  glw_SendMsg(window_GetConnection(win),REQ_SWINEVENT,id,msg,5*4);

  debug_End();

  return(0);
}


int net_SerCreateCheckList(tag *taglist, u8 *msg)
{
  int ret=-1,i;
  tag *t;
  int check_count;

  debug_Begin();

  if(taglist!=NULL)
  {
    if(NULL!=(t=tag_FindTag(taglist,TAG_WIN_CHECKLIST)))
    {
      check_count=(int)t->Data;
      if(0L!=(t->Data=(u32)mem_malloc((check_count+1)*sizeof(gadget_Check_t))))
      {
        for(i=0;i<check_count;i++)
        {
          ((gadget_Check_t *)t->Data)[i].gadget_id=net_MarshalGetLong(&msg);
          ((gadget_Check_t *)t->Data)[i].class_name=net_MarshalGetString(&msg);
//          ((gadget_Check_t *)t->Data)[i].class_id=net_MarshalGetLong(&msg);
          ((gadget_Check_t *)t->Data)[i].flags=net_MarshalGetLong(&msg);
        }
        ((gadget_Check_t *)t->Data)[check_count].gadget_id=GADGET_ILLEGAL_ID;
        ((gadget_Check_t *)t->Data)[check_count].class_name=NULL;
        ((gadget_Check_t *)t->Data)[check_count].flags=0L;
        ret=0;
      }
    }
  }

  debug_End();

  return(ret);
}


void net_SerDeleteCheckList(tag *taglist)
{
  tag *t;
  gadget_Check_t *checklist;
  int i;

  debug_Begin();

  if(taglist!=NULL&&NULL!=(t=tag_FindTag(taglist,TAG_WIN_CHECKLIST)))
  {
    checklist=(gadget_Check_t *)t->Data;
    for(i=0;checklist[i].gadget_id!=GADGET_ILLEGAL_ID;i++)
    {
      if(NULL!=checklist[i].class_name) mem_free(checklist[i].class_name);
    }
    mem_free(checklist);
  }

  debug_End();
}


int net_SerProcessMessage(u32 conn, u32 userdata, struct glw_SockMsg *msg)
{
  int ret=0,stored=0,fromwait=0;
  struct glw_ConnUser *cuser=(struct glw_ConnUser *)conn;
  u8 *bd;
  tag *taglist;
  u32 retval,gadget_id,method;
  Window_t *window;
  struct net_File *retfile;

  debug_Begin();

  if(msg==NULL) fromwait=1;
  do
  {
    if(fromwait!=0) msg=net_MsgFromWaitList(conn);
    if(msg==NULL) break;
//    printf("%s() socket message arrived. (w=0x%02x) type=0x%02x id=%ld length: %ld\n",__FUNCTION__,cuser->waitfor,msg->type,msg->id,msg->length);
    bd=msg->body;
    switch(msg->type)
    {
      case REQ_SAPP|FL_REPLY:
        debug_Message("REQ_SAPP|FL_REPLY");
      case REQ_SECHO|FL_REPLY:
      {
        debug_Message("REQ_SECHO|FL_REPLY");
        break;
      }
      case REQ_SLOADFILES|FL_REPLY:
      {
        debug_Message("REQ_SLOADFILES|FL_REPLY");
        if(cuser->waitfor==msg->type&&msg->id==cuser->userdata)
        {
          if(NULL!=(retfile=mem_malloc(sizeof(struct net_File))))
          {
            retfile->data=net_MarshalGetBinary(&bd,&retfile->size);
            cuser->waitfor=REQ_NONE;
            cuser->userdata=(u32)retfile;
            ret=1;
          }
        }
        else
        {
          debug_Error("loadfiles: wrong message order!");
        }
        break;
      }
      case REQ_SLOADFILE|FL_REPLY:
      {
        debug_Message("REQ_SLOADFILE|FL_REPLY");
        if(cuser->waitfor==msg->type&&msg->id==cuser->userdata)
        {
          cuser->userdata=0L;
          if(NULL!=(retfile=mem_malloc(sizeof(struct net_File))))
          {
            retfile->type=net_MarshalGetLong(&bd);
            retfile->realsize=net_MarshalGetLong(&bd);
            retfile->data=net_MarshalGetBinary(&bd,&retfile->size);
            debug_Message("file received...");
            cuser->waitfor=REQ_NONE;
            cuser->userdata=(u32)retfile;
            ret=1;
          }
        }
        else
        {
          debug_Error("loadfile: wrong message order!");
        }
        break;
      }
      case REQ_CWINSLEEP:
      {
        debug_Message("REQ_CWINSLEEP");
        window=(Window_t *)net_MarshalGetLong(&bd);
        if(window!=NULL) window->sleep++;
        break;
      }
      case REQ_CWINAWAKE:
      {
        debug_Message("REQ_CWINAWAKE");
        window=(Window_t *)net_MarshalGetLong(&bd);
        if(window!=NULL) window->sleep--;
        break;
      }
      case REQ_CECHO:
      {
        debug_Message("REQ_ECHO");
//        printf("Sending echo\n");
        glw_SendMsg(conn,msg->type|FL_REPLY,msg->id,NULL,0);
        break;
      }
      case REQ_SWINEVENT|FL_REPLY:
      {
        debug_Message("REQ_SWINEVENT|FL_REPLY");
        ret=net_MarshalGetLong(&bd);
        if(ret!=0L)
        {
          u32 gadget_id,event;

          window=(Window_t *)net_MarshalGetLong(&bd);
          gadget_id=net_MarshalGetLong(&bd);
          event=net_MarshalGetLong(&bd);
//          printf("Event discard requested: id=%ld  event=%ld\n",gadget_id,event);
          gadget_SetDiscardMask((Gadget_t *)gadget_SearchInWindow(TAG_GADGET_WINDOW,window,TAG_GADGET_GADGET_ID,gadget_id,TAG_DONE),event,0L);
        }
        //MSG ha a ret!=0 akkor van meg az uzenetben valami.
        //MSG gadget_id, event -> ezt felvenni a window deny listajara
        //MSG tehat ha a window ettol a gadgettol egy ilyen uzenetet akarna
        //MSG kuldeni legkozelebb, az blokkolodik.
//MSG        printf("REPLY: msg id=%ld\n",msg->id);
        break;
      }
      case REQ_CCALLGAD:
      {
        debug_Message("REQ_CCALLGAD");
        if(cuser->waitfor==REQ_NONE)
        {
          window=(Window_t *)net_MarshalGetLong(&bd);
          gadget_id=net_MarshalGetLong(&bd);
          method=net_MarshalGetLong(&bd);
          taglist=net_MarshalGetTaglist(&bd);
          retval=gadget_MethodCall(TAG_GADGET_WINDOW,window,
                                             TAG_GADGET_GADGET_ID,gadget_id,
                                             TAG_GADGET_METHOD,method,
                                             TAG_MORE,taglist);
          net_MarshalFreeTaglist(taglist);
          retval=glw_htonl(retval);
          glw_SendMsg(conn,msg->type|FL_REPLY,msg->id,(u8 *)&retval,4);
        }
        else
        {
          stored=net_MsgToWaitList(conn,msg);
        }
        break;
      }
      case REQ_CCLOSEWIN:
      {
        debug_Message("REQ_CCLOSEWIN");
        window_CloseWindow(TAG_WIN_OBJECT,(Window_t *)net_MarshalGetLong(&bd),TAG_DONE);
        break;
      }
      case REQ_COPENWIN:
      {
        char *wname;
        u32 app,flags;
        u8 reply[4];

        debug_Message("REQ_COPENWIN");
        if(cuser->waitfor==REQ_NONE)
        {
          app=net_MarshalGetLong(&bd);
          wname=net_MarshalGetString(&bd);
          flags=net_MarshalGetLong(&bd);
          taglist=net_MarshalGetTaglist(&bd);
          net_SerCreateCheckList(taglist,bd);
          retval=(u32)window_OpenWindow(    TAG_WIN_APP,(gui_App_t *)app,
                                                                    TAG_WIN_NAME,wname,
                                                                    TAG_WIN_EVENT_HANDLER,net_ServerWindowEventHandler,
                                                                    TAG_WIN_FLAGS,flags,
                                                                    TAG_MORE,taglist);
          mem_free(wname);
          net_SerDeleteCheckList(taglist);
          net_MarshalFreeTaglist(taglist);
          net_MarshalPutLong(reply,retval);
          glw_SendMsg(conn,msg->type|FL_REPLY,msg->id,reply,sizeof(reply));
          window_WindowEvent(((Window_t *)retval),0L,CBK_WINDOW_OPENED,((Window_t *)retval)->userdata);
        }
        else
        {
          stored=net_MsgToWaitList(conn,msg);
        }
        break;
      }
      case REQ_CCLOSEAPP:
      {
        debug_Message("REQ_CCLOSEAPP");
        cuser->quit=1;
        ret=1;
        break;
      }
      case REQ_CNEWSKIN:
      {
        Window_t *win;
        char *skinname;
        // win, skinname
        win=(Window_t *)net_MarshalGetLong(&bd);
        skinname=net_MarshalGetString(&bd);
        window_ChangeSkin(TAG_WIN_OBJECT,win,TAG_WIN_SKINNAME,skinname,TAG_DONE);
        mem_free(skinname);
        break;
      }
      default:
      {
        debug_Error("Illegal message type");
      }
    }
    if(stored==0)
    {
      if(NULL!=msg&&NULL!=msg->body) mem_free(msg->body);
      if(NULL!=msg) mem_free(msg);
    }
    msg=NULL;
  }
  while(fromwait==0);

  debug_End();

  return(ret);
}


struct net_FileCache *net_FindFileCache(u32 conn, char *name)
{
  struct net_FileCache *ret=NULL,*file;
  struct glw_ConnUser *cuser=(struct glw_ConnUser *)conn;
  Node_t *node,*head;
  int i;

  debug_Begin();

  for(i=0,node=head=list_GetNodeHead(cuser->file_cache);node!=NULL;node=list_GetNodeNext(cuser->file_cache,node),i++)
  {
    file=(struct net_FileCache *)list_GetNodeData(node);
    if(strcmp(file->name,name)==0) break;
  }
  if(node!=NULL)
  {
    if(node!=head&&i>3)
    {
      list_RemoveNode(cuser->file_cache,node);
      list_InsertNodeHead(cuser->file_cache,node);
    }
    ret=file;
  }

  debug_End();

  return(ret);
}


void net_InsertFileCache(u32 conn, char *name, u8 *data, int size)
{
  struct glw_ConnUser *cuser=(struct glw_ConnUser *)conn;
  Node_t *node;
  struct net_FileCache *file;

  debug_Begin();

  if(NULL!=(node=list_CreateNode()))
  {
    if(NULL!=(file=mem_malloc(sizeof(struct net_FileCache))))
    {
      if(NULL!=(file->name=mem_malloc(strlen(name)+1)))
      {
        if(NULL!=(file->data=mem_malloc(size)))
        {
          strcpy(file->name,name);
          memcpy(file->data,data,size);
          file->size=size;
          list_SetNodeData(node,file);
          list_InsertNodeHead(cuser->file_cache,node);
        }
      }
    }
  }

  debug_End();
}


/*
 * valojaban struct net_Files -t var a filelist parameterben
 *  ha a megkapott listaban meg vannak file-ok, akkor
 *    kiolvassuk a kovetkezot (mint a LoadFile-nal) es visszaadjuk.
 *    aktualizaljuk a strukturat
 *  ha nincs tobb, vagy ez volt az utolso,
 *  akkor felszabaditjuk a data reszet a strukturanak es jelezzuk, hogy ures.
 *  ha eredetileg is ureset kaptunk, akkor NULL
 */
u32 net_FilelistGetNext(u32 firsttag, ...)
{
  return(net_FilelistGetNextTL((tag *)&firsttag));
}
u32 net_FilelistGetNextTL(tag *taglist)
{
  u32 conn;
  struct net_Files *filelist;
  int *len;

  u8 *ret=NULL,*file;
  struct net_File retfile;
  u32 realsize;


  debug_Begin();

  conn=(u32 )tag_GetTagData(taglist,TAG_NET_CONN,0L);
  filelist=(struct net_Files *)tag_GetTagData(taglist,TAG_NET_FILELIST,0L);
  len=(int *)tag_GetTagData(taglist,TAG_NET_LEN,0L);


  if(filelist!=NULL&&filelist->file_count>filelist->readed)
  {
    retfile.type=net_MarshalGetLong(&filelist->next_data);
    retfile.realsize=net_MarshalGetLong(&filelist->next_data);
    retfile.data=net_MarshalGetBinary(&filelist->next_data,&retfile.size);
    filelist->readed++;
    if(retfile.type==FT_DEFLATED)
    {
      realsize=retfile.realsize;
      if(NULL!=(file=mem_malloc(realsize)))
      {
        uncompress(file,&realsize,retfile.data,retfile.size);
        mem_free(retfile.data);
        if(retfile.realsize!=realsize) debug_Error("Corrupt file received!");
        retfile.data=file;
        retfile.size=realsize;
      }
      else
      {
        mem_free(retfile.data);
        retfile.data=NULL;
        retfile.size=0;
        retfile.realsize=0;
      }
    }
    ret=retfile.data;
    if(len!=NULL) *len=retfile.size;
  }

  debug_End();

  return((u32)ret);
}



/* egy file-listat lehet felszabaditani vele, akar kiolvastuk belole
 * a file-okat, akar nem.
 */
u32 net_FilelistFree(u32 firsttag, ...)
{
  return(net_FilelistFreeTL((tag *)&firsttag));
}
u32 net_FilelistFreeTL(tag *taglist)
{
  u32 conn;
  struct net_Files *filelist;


  debug_Begin();

  conn=(u32 )tag_GetTagData(taglist,TAG_NET_CONN,0L);
  filelist=(struct net_Files *)tag_GetTagData(taglist,TAG_NET_FILELIST,0L);

  if(filelist!=NULL)
  {
    if(filelist->data!=NULL) mem_free(filelist->data);
    mem_free(filelist);
  }

  debug_End();

  return(0L);
}

/*
 * a names tombben szereplo file-okat keri el a klienstol es megvarja a valaszt
 *  keres formatuma:
 *    u32     file-ok szama
 *    string  1. nev
 *    string  2. nev
 *    string  N. nev
 *
 *  valasz formatuma:
 *    az eddigi file formatumbol a kert mennyiseg
 *
 *  a valaszt elhelyezzuk egy memoriateruleten, ahol ezenkivul meg a file-ok szamat is
 *  taroljuk. struct net_Files -ban.
 */
u32 net_FilelistLoad(u32 firsttag, ...)
{
  return(net_FilelistLoadTL((tag *)&firsttag));
}
u32 net_FilelistLoadTL(tag *taglist)
{
  u32 conn;
  char **names;

  struct net_Files *ret=NULL;
  struct net_File *retfile;
  int i,msglen=0,strcnt;
  u8 *msg,*m;
  u32 id;


  debug_Begin();

  conn=(u32 )tag_GetTagData(taglist,TAG_NET_CONN,0L);
  names=(char **)tag_GetTagData(taglist,TAG_NET_NAMES,0L);

  if(names!=NULL&&conn!=0L)
  {
    for(i=0;names[i]!=NULL;i++) msglen+=net_StrMsgLen(names[i]);
    strcnt=i;
    msglen+=4;
    if(NULL!=(msg=mem_malloc(msglen)))
    {
      if(NULL!=(ret=mem_malloc(sizeof(struct net_Files))))
      {
        m=msg;
        m=net_MarshalPutLong(m,(u32)strcnt);
        for(i=0;i<strcnt;i++) m=net_MarshalPutString(m,names[i]);
        id=net_GetServerId();
        net_SetState(conn,REQ_SLOADFILES|FL_REPLY,id);
        glw_SendMsg(conn,REQ_SLOADFILES,id,msg,msglen);
        mem_free(msg);
        glw_MainLoop(conn,0L,~GLWEV_SOCKET);
        retfile=(struct net_File *)net_GetUserData(conn);
        ret->file_count=strcnt;
        ret->readed=0;
        ret->data_size=retfile->size;
        ret->data=retfile->data;
        ret->next_data=ret->data;
        mem_free(retfile);
      }
    }
  }

  debug_End();

  return((u32)ret);
}


u32 net_LoadFile(u32 firsttag, ...)
{
  return(net_LoadFileTL((tag *)&firsttag));
}
u32 net_LoadFileTL(tag *taglist)
{
  u32 conn;
  u8 *name;
  int *len;

  char *file=NULL;
  struct net_FileCache *fcache;

  debug_Begin();

  conn=(u32 )tag_GetTagData(taglist,TAG_NET_CONN,0L);
  name=(u8 *)tag_GetTagData(taglist,TAG_NET_NAME,0L);
  len=(int *)tag_GetTagData(taglist,TAG_NET_LEN,0L);

  debug_Message("request: '%s'",name);
  if(NULL!=(fcache=net_FindFileCache(conn,name)))
  {
    if(NULL!=(file=mem_malloc(fcache->size)))
    {
      memcpy(file,fcache->data,fcache->size);
      if(len!=NULL) *len=fcache->size;
    }
  }
  else
  {
    char *name2;
    char *msg;
    char *f2;
    struct net_File *retfile;
    int msglen;
    u32 id,rs;

    if(NULL!=(name2=mem_malloc(strlen(name)+6+1)))
    {
      strcpy(name2,"files/");
      strcat(name2,name);
      if(net_GetWaitfor(conn)!=REQ_NONE) debug_Error("Nested file request! filename: '%s'",name);
      msglen=net_StrMsgLen(name2);
      if(NULL!=(msg=mem_malloc(msglen)))
      {
        net_MarshalPutString(msg,name2);
        id=net_GetServerId();
        net_SetState(conn,REQ_SLOADFILE|FL_REPLY,id);
        glw_SendMsg(conn,REQ_SLOADFILE,id,msg,msglen);
        mem_free(msg);
        glw_MainLoop(conn,0L,~GLWEV_SOCKET);
        if(NULL!=(retfile=(struct net_File *)net_GetUserData(conn)))
        {
          if(retfile->type==FT_DEFLATED)
          {
            rs=retfile->realsize;
            if(NULL!=(f2=mem_malloc(rs)))
            {
              uncompress(f2,&rs,retfile->data,retfile->size);
              mem_free(retfile->data);
              if(retfile->realsize!=rs) debug_Error("Corrupt file received!");
              retfile->data=f2;
              retfile->size=retfile->realsize;
            }
            else
            {
              mem_free(retfile->data);
              retfile->data=NULL;
              retfile->size=0;
              retfile->realsize=0;
            }
          }
          debug_Message("FILE INFO: name='%s' size=%d bytes",name,retfile->size);
          if(len!=NULL) *len=retfile->size;
          if(retfile->size>0)
          {
            file=retfile->data;
            net_InsertFileCache(conn,name,file,retfile->size);
          }
          else mem_free(retfile->data);
          mem_free(retfile);
        }
      }
      mem_free(name2);
    }
  }

  debug_End();

  return((u32)file);
}



int net_Init(void)
{
  int ret=-1;

  debug_Begin();

//Initialize call vector BEGIN - put this into the init function of this module
  call_vector[NET_FILELISTGETNEXT-NET_FUNCBASE]=net_FilelistGetNextTL;
  call_vector[NET_FILELISTFREE-NET_FUNCBASE]=net_FilelistFreeTL;
  call_vector[NET_FILELISTLOAD-NET_FUNCBASE]=net_FilelistLoadTL;
  call_vector[NET_LOADFILE-NET_FUNCBASE]=net_LoadFileTL;
  bases_modules.net_Call=net_Call;
  bases_modules.net_CallTL=net_CallTL;
//Initialize call vector END

  ret=0;

  debug_End();

  return(ret);
}


void net_CleanUp(void)
{
  debug_Begin();
  debug_End();
}


//END//

u32 net_Call(int function, u32 firsttag, ...)
{
  return(net_CallTL(function,(tag *)&firsttag));
}
u32 net_CallTL(int function, tag *taglist)
{
  u32 ret=~0L;

  debug_Begin();

  debug_Message("function ID : %d",function-NET_FUNCBASE);

  if(function>=NET_FUNCBASE&&function<NET_FUNC_DONE)
  {
    ret=call_vector[function-NET_FUNCBASE](taglist);
  }
  else debug_Warning("%s(): Function code out of range! code=0x%04x",__FUNCTION__,function);

  debug_End();

  return(ret);
}

---