SUPのコーディング例を次に示します。

  10  /*
  20   * SUP01
  30   */
  40  #include <stdio.h>
  50  #include <string.h>
  60  #include <dcrpc.h>
  70  #include <dctrn.h>
  80  
  90  main()
 100  {
 110  /*
 120   *変数の定義
 130   */
 140    static char   in_buf[1024];
 150    static DCLONG in_buf_len;
 160    static char   out_buf[1024];
 170    static DCLONG out_buf_len;
 180    int rc;
 190  /*
 200   *RPC-OPEN(UAPの開始)
 210   */
 220    rc = dc_rpc_open(DCNOFLAGS);
 230    /*OpenTP1の各種関数を使う準備をする(各機能の初期化)*/
 240    if(rc != DC_OK) {
 250      printf("SUP01:dc_rpc_openに失敗しました。CODE = %d \n",rc);
 260      goto PROG_END;
 270    }
 280  /*
 290   *ADM-COMPLETE(ユーザサーバの開始処理完了の報告)
 300   */
 310    rc = dc_adm_complete(DCNOFLAGS);
 320    if(rc != DC_OK){
 330      printf("SUP01:dc_adm_completeに失敗しました。CODE = %d \n",rc);
 340      goto PROG_END;
 350    }
 360  /*
 370   *TRN_BEGIN(トランザクションの開始)
 380   */
 390    rc = dc_trn_begin();
 400    if(rc != DC_OK) {
 410      printf("SUP01:dc_trn_beginに失敗しました。CODE = %d \n",rc);
 420      goto TRAN_END;
 430    }
 440    /*
 450     *RPC-CALL(遠隔サービスの要求)
 460     */
 470    strcpy(in_buf,"SUP01:DATA OpenTP1!!");
 480    in_buf_len = strlen(in_buf) + 1;
 490    out_buf_len = 1024;
 500    rc = dc_rpc_call("spp01grp","svr01",in_buf,&in_buf_len,
 510    out_buf,&out_buf_len,DCNOFLAGS);
 520    if(rc != DC_OK) {
 530      printf("SUP01:サービス要求に失敗しました。CODE = %d \n",rc);
 540      goto TRAN_END;
 550    }
 560    printf("SUP01:SERVICE FUNCTION RETURN = %s\n",out_buf);
 570  /*
 580   *TRN-UNCHAINED-COMMIT(非連鎖モードのコミット)
 590   */
 600    TRAN_END:
 610    rc = dc_trn_unchained_commit();
 620    if(rc != DC_OK) {
 630      printf("SUP01:dc_trn_unchained_commitに失敗しました。CODE = %d \n",rc);
 640    }
 650  /*
 660   *RPC-CLOSE(UAPの終了)
 670   */
 680    PROG_END:
 690    dc_rpc_close(DCNOFLAGS);
 700    printf("SUP01:処理を終了しました。\n");
 710    exit(0);
 720  }

SPPのメイン関数のコーディング例を次に示します。

  10  /*
  20   *SPP01 メイン関数
  30   */
  40  #include <stdio.h>
  50  #include <dcrpc.h>
  60  #include <dcdam.h>
  70  #define DAMFILE "damfile0"
  80  
  90  int damfd;   /* damfile file-id */
 100  
 110  main()
 120  {
 130  /*
 140   *リターン値を格納する領域の定義
 150   */
 160    int rc;
 170  /*
 180   *RPC-OPEN(UAPの開始)
 190   */
 200    rc = dc_rpc_open(DCNOFLAGS);
 210    if(rc != DC_OK) {
 220      printf("SPP01:dc_rpc_openに失敗しました。CODE = %d \n",rc);
 230      goto PROG_END;
 240    }
 250  /*
 260   *DAM-OPEN(論理ファイルのオープン)
 270   */
 280    rc = dc_dam_open(DAMFILE,DCDAM_BLOCK_EXCLUSIVE);
 290    if(rc < DC_OK) {
 300      printf("SVR01:dc_dam_openに失敗しました。CODE = %d \n",rc);
 310      goto DAM_END;
 320    }
 330    damfd = rc;
 340  /*
 350   *RPC-MAINLOOP(SPPのサービス開始)
 360   */
 370    printf("SPP01:mainloopに入ります。\n");
 380    rc = dc_rpc_mainloop(DCNOFLAGS);
 390    if(rc != DC_OK) {
 400      printf("SPP01:dc_rpc_mainloop \
 410          に失敗しました。CODE = %d \n",rc);
 420    }
 430  /*
 440   *DAM-CLOSE(論理ファイルのクローズ)
 450   */
 460    DAM_END:
 470    rc = dc_dam_close(damfd,DCNOFLAGS);
 480    if(rc != DC_OK) {
 490      printf("SVR01:dc_dam_closeに失敗しました。CODE = %d\n",rc);
 500    }
 510  /*
 520   *RPC-CLOSE(UAPの終了)
 530   */
 540    PROG_END:
 550    dc_rpc_close(DCNOFLAGS);
 560    printf("SPP01:SPPのサービス処理を終了します。\n");
 570    exit(0);
 580  }

SPPのサービス関数のコーディング例を次に示します。

  10  /*
  20   *SVR01 サービス関数
  30   */
  40  #include <stdio.h>
  50  #include <string.h>
  60  #include <dcrpc.h>
  70  #include <dcdam.h>
  80  #define DAMFILE "damfile0"
  90  #define DAM_BLK_SIZE 504
 100  #define REWRITE_LEN 19
 110  extern int damfd;
 120  
 130  void svr01(in_data,in_leng,out_data,out_leng)
 140    char   *in_data;
 150    DCLONG *in_leng;
 160    char   *out_data;
 170    DCLONG *out_leng;
 180  {
 190  /*
 200   *変数の定義
 210   */
 220    static struct DC_DAMKEY keyptr;
 230    static char *damc_buf;
 240    static char dam_cntl_buf[DAM_BLK_SIZE];  
 250    static char write_buf[DAM_BLK_SIZE];
 260    struct dam_cntl_p {
 270      int w_point;
 280      char rewrite_data[REWRITE_LEN];
 290    } *dam_cntl_p;
 300    int rc;
 310    int write_size;
 320    int rewrite_size;
 330    int damc_buf_size;
 340  
 350    keyptr.fstblkno = 0;
 360    keyptr.endblkno = 0;
 370    damc_buf_size = DAM_BLK_SIZE;
 380    printf("SVR01:処理の開始 \n");
 390  /*
 400   *DAM_READ(論理ファイルからブロックの入力)
 410   */
 420    rc = dc_dam_read(damfd,&keyptr,1,dam_cntl_buf,
 430    damc_buf_size,DCDAM_MODIFY);
 440    if(rc != DC_OK) {
 450      printf("SVR01:dc_dam_readに失敗しました。CODE = %d \n",rc);
 460      strcpy(out_data,"SVR01:DAM READ FAILED");
 470      *out_leng = strlen(out_data);
 480      goto PROG_END;
 490    }
 500  /*
 510   *DAM_WRITE(論理ファイルへブロックの出力)
 520   *DAM_REWRITE(論理ファイルのブロックの更新)
 530   */
 540    DAM_WRITE:
 550    dam_cntl_p = (struct dam_cntl_p *)dam_cntl_buf;
 560    write_size = DAM_BLK_SIZE;
 570    memcpy(write_buf,in_data,*in_leng);
 580    dam_cntl_p->w_point = dam_cntl_p->w_point + 1;
 590    keyptr.fstblkno = dam_cntl_p->w_point;
 600    keyptr.endblkno = 0;
 610    rc = dc_dam_write(damfd,&keyptr,1,write_buf,
 620    write_size,DCNOFLAGS);
 630    if(rc != DC_OK) {
 640      if(rc == DCDAMER_BNOER) {
 650        dam_cntl_p->w_point = 0;
 660        goto DAM_WRITE;
 670      }
 680      printf("SVR01:dc_dam_writeに失敗しました。CODE = %d \n",rc);
 690      strcpy(out_data,"SVR01;DAM WRITE FAILED");
 700      *out_leng = strlen(out_data);
 710      goto PROG_END;
 720    }
 730    keyptr.fstblkno = 0;
 740    keyptr.endblkno = 0;
 750    damc_buf_size = DAM_BLK_SIZE;
 760    sprintf(dam_cntl_p->rewrite_data,"REWRITE COMPLETE\n");
 770    rc = dc_dam_rewrite(damfd,&keyptr,1,dam_cntl_buf,
 780    damc_buf_size,DCDAM_UPDATE);
 790    if(rc != DC_OK) {
 800      printf("SVR01:dc_dam_rewriteに失敗しました。CODE = %d\n",rc);
 810      strcpy(out_data,"SVR01:DAM REWRITE FAILED");
 820      *out_leng = strlen(out_data);
 830    }
 840    strcpy(out_data,"SVR01:PROCESS COMPLETE");
 850    *out_leng = strlen(out_data);
 860    PROG_END:
 870    printf("SVR01:処理を終了します。\n");
 880    return;
 890  }