The following shows a coding example for the SPP main function.

  10  /*
  20   * spp01 main function
  30   */
  40  #include <stdio.h>
  50  #include <dcrpc.h>
  60  #include <dctam.h>
  70  #define  TAMTABLE    "tamtable30"
  80  
  90  long  tamfd ;      /* tamfile file-id  */
 100  
 110  main()
 120  {
 130  
 140  /*
 150   * Define a return code storage variable
 160   */
 170    int    rcd ;
 180  /*
 190   * RPC-OPEN (start the UAP)
 200   */
 210    rcd = dc_rpc_open(DCNOFLAGS) ;
 220    if(rcd != DC_OK) {
 230      printf("SPP01:dc_rpc_open failed. "
 235             "code = %d \n", rcd) ;
 240      goto PROG_END ;
 250    }
 260  /*
 270   * TAM-OPEN (open a TAM table)
 280   */
 290    rcd = dc_tam_open(TAMTABLE, DCTAM_REC_EXCLUSIVE) ;
 300    if(rcd <= 0) {
 310      printf("SVR01:dc_tam_open failed. "
 315             "code = %d \n", rcd) ;
 320      goto TAM_END ;
 330    }
 340    tamfd = (long)rcd ;
 350  /*
 360   * RPC-MAINLOOP (start the SPP service)
 370   */
 380    rcd = dc_rpc_mainloop(DCNOFLAGS) ;
 390    if(rcd != DC_OK) {
 400      printf("SPP01:dc_rpc_mainloop failed. "
 405             "code = %d \n", rcd) ;
 410    }
 420  /*
 430   * TAM-CLOSE (close the TAM table)
 440   */
 450    rcd = dc_tam_close(tamfd, DCNOFLAGS) ;
 460    if(rcd != DC_OK) {
 470      printf("SVR01:dc_tam_close failed. "
 475             "code = %d \n", rcd) ;
 480    }
 490  TAM_END :
 500  /*
 510   * RPC-CLOSE (terminate the UAP)
 520   */
 530    dc_rpc_close(DCNOFLAGS) ;
 540  PROG_END :
 550    printf("SPP01:The SPP service processing is "
 555           "terminated. \n") ;
 560    exit(0) ;
 570  }

The following shows a coding example for the SPP service function.

  10  /*
  20   * srv01 service function
  30   */
  40  #include <stdio.h>
  50  #include <string.h>
  60  #include <dctam.h>
  70  #define  TAM_REC_SIZE  128
  80  
  90  extern  long tamfd ;   /* tamfile file-id */
 100  
 110  void svr01(in_data, in_leng, out_data, out_leng)
 120    char *in_data ;
 130    long *in_leng ;
 140    char *out_data ;
 150    long *out_leng ;
 160  {
 170  
 180  /*
 190   * Define variables
 200   */
 210    static struct DC_TAMKEY keyptr ;
 220    static char   *tamc_buf ;
 230    static char   tam_cntl_buf[TAM_REC_SIZE] ;
 240    static char   write_buf[TAM_REC_SIZE] ;
 250    struct tam_cntl_p {
 260                       char keyname[10] ;
 270                       char filler[118] ;
 280                      } *tam_cntl_p ;
 290    int    rcd ;
 300    int    write_size ;
 310    int    tamc_buf_size ;
 320    static char keypar[4][10] = {
 330                       { 0x00, 0x00, 0x00, 0x00, 0x00,
 340                         0x00, 0x00, 0x00, 0x00, 0x01} ,
 350                       { 0x00, 0x00, 0x00, 0x00, 0x00,
 360                         0x00, 0x00, 0x00, 0x00, 0x02} ,
 370                       { 0x00, 0x00, 0x00, 0x00, 0x00,
 380                         0x00, 0x00, 0x00, 0x00, 0x03} ,
 390                       { 0x00, 0x00, 0x00, 0x00, 0x00,
 400                         0x00, 0x00, 0x00, 0x00, 0x04} ,
 410                                } ;
 420    printf("SVR01:Start of processing \n") ;
 430  /*
 440   * TAM_READ (read the first record from the TAM table)
 450   */
 460    keyptr.keyname = keypar[0] ;
 470    tamc_buf_size = TAM_REC_SIZE ;
 480    rcd = dc_tam_read(tamfd, &keyptr, 1, tam_cntl_buf,
 490                      tamc_buf_size, 
 495                      DCTAM_EQLSRC | DCTAM_MODIFY) ;
 500    if(rcd != DC_OK) {
 510      printf("SVR01:dc_tam_read failed. "
 515             "code = %d \n", rcd) ;
 520      strcpy(out_data, "SVR01:TAM READ FAILED") ;
 530      *out_leng = strlen(out_data) ;
 540      goto PROG_END ;
 550    }
 560  /*
 570   * TAM_REWRITE (update the first record of TAM table 
 575   *              on the assumption of search)
 580   */
 590    tam_cntl_p = (struct tam_cntl_p *)tam_cntl_buf ;
 600    memcpy(tam_cntl_p->filler, in_data, *in_leng) ;
 610    rcd = dc_tam_rewrite(tamfd, &keyptr, 1, tam_cntl_buf,
 620                         tamc_buf_size, DCNOFLAGS) ;
 630    if(rcd != DC_OK) {
 640      printf("SVR01:dc_tam_rewrite failed. "
 645             "code = %d \n", rcd) ;
 650      strcpy(out_data, "SVR01:TAM REWRITE FAILED") ;
 660      *out_leng = strlen(out_data) ;
 670      goto PROG_END ;
 680    }
 690  /*
 700   * TAM_WRITE (update the second record of TAM table)
 710   */
 720    keyptr.keyname = keypar[1] ;
 730    tam_cntl_p = (struct tam_cntl_p *)write_buf ;
 740    memcpy(tam_cntl_p->keyname, keypar[1], 10) ;
 750    memcpy(tam_cntl_p->filler, in_data, *in_leng) ;
 760    write_size = TAM_REC_SIZE ;
 770    rcd = dc_tam_write(tamfd, &keyptr, 1, tam_cntl_p,
 780                              write_size, DCTAM_WRITE) ;
 790    if(rcd != DC_OK) {
 800      printf("SVR01:dc_tam_write failed. "
 805             "code = %d \n", rcd) ;
 810      strcpy(out_data, "SVR01:TAM WRITE FAILED") ;
 820      *out_leng = strlen(out_data) ;
 830      goto PROG_END ;
 840    }
 850  /*
 860   * TAM_READ (read the third record from the TAM table)
 870   */
 880    keyptr.keyname = keypar[2] ;
 890    tamc_buf_size = TAM_REC_SIZE ;
 900    rcd = dc_tam_read(tamfd, &keyptr, 1, tam_cntl_buf,
 910                      tamc_buf_size, 
 905                      DCTAM_EQLSRC | DCTAM_MODIFY) ;
 920    if(rcd != DC_OK) {
 930      printf("SVR01:dc_tam_read failed. "
 935             "code = %d \n", rcd) ;
 940      strcpy(out_data, "SVR01:TAM READ FAILED") ;
 950      *out_leng = strlen(out_data) ;
 960      goto PROG_END ;
 970    }
 980  /*
 990   * TAM_READ_CANCEL (cancel the search for the third 
 995   * record of the TAM table)
1000   */
1010    rcd = dc_tam_read_cancel(tamfd, &keyptr, 
1015                             1, DCNOFLAGS) ;
1020    if(rcd != DC_OK) {
1030      printf("SVR01:dc_tam_read_cancel failed. "
1040             "code = %d \n",rcd) ;
1050      strcpy(out_data, "SVR01:TAM READ CANCEL FAILED") ;
1060      *out_leng = strlen(out_data) ;
1070      goto PROG_END ;
1080    }
1090  /*
1100   * TAM_delete (delete the fourth record of the 
1105   *             TAM table)
1110   */
1120    keyptr.keyname = keypar[3] ;
1130    rcd = dc_tam_delete(tamfd, &keyptr, 1,
1140                               NULL, 0, DCTAM_NOOUTREC) ;
1150    if(rcd != DC_OK) {
1160      printf("SVR01:dc_tam_delete failed. "
1165             "code = %d \n", rcd) ;
1170      strcpy(out_data, "SVR01:TAM DELETE FAILED") ;
1180      *out_leng = strlen(out_data) ;
1190      goto PROG_END ;
1200    }
1210    strcpy(out_data, "SVR01:PROCESS COMPLETE") ;
1220    *out_leng = strlen(out_data) ;
1230  PROG_END :
1240    printf("SVR01:Processing is terminated.\n") ;
1250    return ;
1260  }