OpenTP1 Version 7 Programming Reference C Language
The figure below shows an example of a client/server configuration UAP. This section presents only an SPP coding sample. This example assumes that the same SUP as in 7.1 Coding samples for client/server configuration UAPs (SUP, SPP DAM access) requests this SPP for service.
Figure 7-2 Client/server configuration UAP sample (TAM access)
This section presents a coding example based on the configuration sample shown in the figure.
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 }
All Rights Reserved. Copyright (C) 2006, 2010, Hitachi, Ltd.