home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ctcoll95.zip / BASTELST / PAPI020.ZIP / APIOP.C < prev    next >
C/C++ Source or Header  |  1993-10-06  |  3KB  |  185 lines
  1. /* Common ISDN API C-Library Functions Basic MS-DOS Functions
  2.     Author: Dietmar Friede
  3. Copyright (c) 1992 D.Friede
  4.  #include "copy"
  5.  #include "copying.doc"
  6. */
  7.  
  8. #define VERSION        "0.18 21.09.1993"
  9.  
  10. #include "stdio.h"
  11. #include <dos.h>
  12. #include <ctype.h>
  13. #include <mem.h>
  14. #include "types.h"
  15. #include "api.h"
  16. #include "head.h"
  17.  
  18. union capi_ptr
  19.  {
  20.     InterruptPtr fptr;
  21.     byte far *   cptr;
  22.  } capi_ptr;
  23.  
  24. static byte check_vec[5] = { 'K','B',0x80,'I','A'};
  25.  
  26. byte capi_int=    CAPI_INT;
  27. unsigned application= 0;
  28. static unsigned save_es;
  29.  
  30. int
  31. api_check(void)
  32. {
  33.     int i;
  34.     byte far *p;
  35.     capi_ptr.fptr= getvect(capi_int);
  36.     p=capi_ptr.cptr;
  37.     p+= 6;
  38.     for( i=0 ; i< 5; i++,p++) 
  39.     if( *p != check_vec[i] )
  40.     {
  41.         printf("no Common-ISDN-API installed\n");
  42.         return 1;
  43.     }
  44.     return 0;
  45. }
  46.  
  47. int
  48. api_register(byte far *buffer, int nmesg, int maxcon, int maxblock, int maxsize)
  49. {
  50.     union REGS regs;
  51.     struct SREGS sregs;
  52.  
  53.     if(application)
  54.     {
  55.         printf("only one application\n");
  56.         return 0;
  57.     }
  58.     segread(&sregs);
  59.     save_es=FP_SEG(buffer);
  60.     sregs.es=save_es;
  61.     regs.x.bx=FP_OFF(buffer);
  62.     regs.x.cx=nmesg;
  63.     regs.x.dx=maxcon;
  64.     regs.x.si=maxblock;
  65.     regs.x.di=maxsize;
  66.     regs.h.ah= 1; /* API_REGISTER */
  67.     int86x(capi_int,®s,®s,&sregs);
  68.     application= regs.x.ax;
  69.     return(regs.x.ax);
  70. }
  71.  
  72. word
  73. api_release()
  74. {
  75.     union REGS regs;
  76.  
  77.     regs.x.dx=application;
  78.     regs.h.ah= 2; /* API_RELEASE */
  79.     int86(capi_int,®s,®s);
  80.     application= 0;
  81.     return(regs.x.ax);
  82. }
  83.  
  84. void freemsg(byte far *message);
  85.  
  86. int
  87. api_put_message(byte far *message)
  88. {
  89.     union REGS regs;
  90.     struct SREGS sregs;
  91.  
  92.     if(message==null) return 1;
  93.     segread(&sregs);
  94.     sregs.es=FP_SEG(message);
  95.     regs.x.bx=FP_OFF(message);
  96.     regs.x.dx=application;
  97.     regs.h.ah= 3; /* API_PUT_MESSAGE */
  98.     int86x(capi_int,®s,®s,&sregs);
  99.     freemsg(message);
  100.  
  101.     return(regs.x.ax);
  102. }
  103.  
  104. int
  105. api_get_message(byte far **message)
  106. {
  107.     union REGS regs;
  108.     struct SREGS sregs;
  109.  
  110.     segread(&sregs);
  111.     sregs.es= save_es;
  112.     regs.x.dx=application;
  113.     regs.h.ah= 4; /* API_GET_MESSAGE */
  114.     int86x(capi_int,®s,®s,&sregs);
  115.     if(regs.x.ax) *message= null;
  116.     else *message= MK_FP(sregs.es,regs.x.bx);
  117.     return(regs.x.ax);
  118. }
  119.  
  120. word
  121. api_set_signal(InterruptPtr function)
  122. {
  123.     union REGS regs;
  124.     struct SREGS sregs;
  125.  
  126.     segread(&sregs);
  127.     sregs.es=FP_SEG(function);
  128.     regs.x.bx=FP_OFF(function);
  129.     regs.x.dx=application;
  130.     regs.h.ah= 5; /* API_SET_SIGNAL */
  131.     int86x(capi_int,®s,®s,&sregs);
  132.     return(regs.x.ax);
  133. }
  134.  
  135. int
  136. api_deinstall(int force)
  137. {
  138.     union REGS regs;
  139.  
  140.     regs.x.bx=force;
  141.     regs.h.ah= 6; /* API_DEINSTALL */
  142.     int86(capi_int,®s,®s);
  143.     return(regs.x.ax);
  144. }
  145.  
  146. void
  147. api_get_manufacturer(byte far *buffer)
  148. {
  149.     union REGS regs;
  150.     struct SREGS sregs;
  151.  
  152.     segread(&sregs);
  153.     sregs.es=FP_SEG(buffer);
  154.     regs.x.bx=FP_OFF(buffer);
  155.     regs.h.ah= 0xf0;
  156.     int86x(capi_int,®s,®s,&sregs);
  157. }
  158.  
  159. void
  160. api_get_version(byte far *buffer)
  161. {
  162.     union REGS regs;
  163.     struct SREGS sregs;
  164.  
  165.     segread(&sregs);
  166.     sregs.es=FP_SEG(buffer);
  167.     regs.x.bx=FP_OFF(buffer);
  168.     regs.h.ah= 0xf1;
  169.     int86x(capi_int,®s,®s,&sregs);
  170. }
  171.  
  172. void
  173. api_get_serial(byte far *buffer)
  174. {
  175.     union REGS regs;
  176.     struct SREGS sregs;
  177.  
  178.     segread(&sregs);
  179.     sregs.es=FP_SEG(buffer);
  180.     regs.x.bx=FP_OFF(buffer);
  181.     regs.h.ah= 0xf2;
  182.     int86x(capi_int,®s,®s,&sregs);
  183. }
  184.  
  185.