DB_STATUS adc_getempty( ADF_CB *adf_scb, DB_DATA_VALUE *adc_emptydv) /* Ptr to empty/null data value */ { i4 bdt = abs((i4) adc_emptydv->db_datatype); i4 bdtv; DB_STATUS db_stat; /* Does the datatype exist? */ bdtv = ADI_DT_MAP_MACRO(bdt); if (bdtv <= 0 || bdtv > ADI_MXDTS || Adf_globs->Adi_dtptrs[bdtv] == NULL) return(adu_error(adf_scb, E_AD2004_BAD_DTID, 0)); /* ** If datatype is non-nullable, call the function associated with this ** datatype to initialize a data value to be "empty". Currently, this is ** only one function for the RTI known datatypes. This level of indirection ** is provided for the implementation of user-defined datatypes in the ** future. ** ** If datatype is nullable, we can set the null value right here since it ** will be done the same way for all nullable datatypes. */ if (adc_emptydv->db_datatype > 0) /* non-nullable */ { db_stat = (*Adf_globs->Adi_dtptrs[ADI_DT_MAP_MACRO(bdt)]-> adi_dt_com_vect.adp_getempty_addr) (adf_scb, adc_emptydv); } else { ADF_SETNULL_MACRO(adc_emptydv); /* ** If the datatype is peripheral, then we clear its length as ** well. This is because ADF guarantees that the lengths are ** always correct for peripheral datatypes */ if (Adf_globs->Adi_dtptrs[ADI_DT_MAP_MACRO(bdt)]-> adi_dtstat_bits & AD_PERIPHERAL) { ((ADP_PERIPHERAL *) adc_emptydv->db_data)->per_length0 = 0; ((ADP_PERIPHERAL *) adc_emptydv->db_data)->per_length1 = 0; ((ADP_PERIPHERAL *) adc_emptydv->db_data)->per_tag = ADP_P_COUPON; } db_stat = E_DB_OK; } return(db_stat); }
/*{ ** Name: adu_rdm2_finish - Finish Redeeming an ADF_COUPON ** ** Description: ** This routine completes the action of redeeming a coupon. ** If running in test mode, this routine makes sure that the ** varchar field is padded out with the appropriate amount of ** garbage. ** ** In general, it places the "closing remarks" in the ** data stream. This means that it will place the final segment ** indicator (saying "no more") in the stream if the stream is ** destined for GCA. If the datatype is nullable, then the null ** bit is set/cleared as appropriate. If there is insufficient ** room to make these closing remarks (or to supply the correct ** amount of garbage in the test case), then the fip_state is set ** to ADW_F_DONE_NEED_NULL, and an incomplete status is returned. ** This status will set up the main redeem call to call this ** routine again with a new buffer, repeating this action until ** all is done. ** ** Inputs: ** adf_scb Standard ADF SCB Ptr ** result_dv Ptr to output area DB_DATA_VALUE ** coupon_dv PTR to input area DB_DATA_VALUE ** work Ptr to ADP_LO_WKSP in which work ** is done. ** ->adw_shared Contains the result of the action ** so far ** ->adw_fip Contains more such results ** for_gca Nat indicating whether the result ** is destined for GCA ** transmission. ** ** Outputs: ** adf_scb->adf_error Filled as appropriate. ** result_dv->db_length Set correctly. ** work->adw_fip.fip_state Set to indicate whether to ** return. ** work->adw_fip.fip_test* Set to control the garbage ** returned for the test cases. ** ** Returns: ** DB_STATUS ** Exceptions: ** None ** ** Side Effects: ** None ** ** History: ** 07-dec-1989 (fred) ** Prototyped. ** 06-oct-1992 (fred) ** Altered to work with timezone integration. As a temporary measure, ** this routine was using the ADF_CB.adf_4rsvd field to store ** some context across calls. In that this field disappeared, a new, ** more appropriately named field was added (adf_lo_context). This ** new ADF_CB field is now used in this file. ** 30-Oct-1992 (fred) ** Fixed to correctly handle being called with a length too short ** for the original header. ** 20-Nov-1992 (fred) ** Rewritten for better clarity & better delineation of ** function in support of OME large objects. [@history_template@]... */ DB_STATUS static adu_rdm2_finish(ADF_CB *adf_scb, DB_DATA_VALUE *result_dv, DB_DATA_VALUE *coupon_dv, ADP_LO_WKSP *work, i4 for_gca) { DB_STATUS status = E_DB_OK; i4 zero = 0; if (work->adw_shared.shd_l1_check != work->adw_fip.fip_l1_value) { /* Fix_me -- get more detailed error message to log (log_key, */ /* what's wrong, etc. */ /* Then we are sending an inconsistent blob */ status = adu_error(adf_scb, E_AD7004_ADP_BAD_BLOB,0); } else if (result_dv->db_length >= (work->adw_shared.shd_o_used + (for_gca * sizeof(i4)) + work->adw_fip.fip_null_bytes)) { if (for_gca) { I4ASSIGN_MACRO(zero, result_dv->db_data[work->adw_shared.shd_o_used]); work->adw_shared.shd_o_used += sizeof(i4); } if (work->adw_fip.fip_test_mode) { work->adw_fip.fip_test_sent += sizeof(i4); if (work->adw_fip.fip_test_sent <= (work->adw_fip.fip_test_length - work->adw_fip.fip_null_bytes)) { /* Then there isn't enough to fill the varchar() */ if (result_dv->db_length < (work->adw_fip.fip_test_length - work->adw_fip.fip_test_sent)) { /* ** This is for test purposes only. ** ** We need to send a true VARCHAR() datatype. ** Thus, if the blob os smaller than that, then we ** need to pad it out with garbage bytes. To do ** so, we will increment test_sent by the ** remainder of the buffer, and happily return, ** knowing that we will arrive here with an empty ** buffer in the relatively near future. ** ** To set test_sent appropriately, we must first ** decrement it by the amount it was incremented ** before arriving here. Then we increment as ** appropriate. */ work->adw_fip.fip_test_sent -= work->adw_shared.shd_o_used; work->adw_fip.fip_test_sent += result_dv->db_length; work->adw_fip.fip_state = ADW_F_DONE_NEED_NULL; adf_scb->adf_errcb.ad_errcode = E_AD0002_INCOMPLETE; status = E_DB_INFO; } } } if (status == E_DB_OK) { result_dv->db_length = work->adw_shared.shd_o_used + work->adw_fip.fip_null_bytes; if (work->adw_fip.fip_null_bytes) { /* ** Then the datatype was nullable. Copy the NULL byte ** from the coupon. */ if (ADI_ISNULL_MACRO(coupon_dv)) { ADF_SETNULL_MACRO(result_dv); } else { ADF_CLRNULL_MACRO(result_dv); } } adf_scb->adf_errcb.ad_errcode = E_DB_OK; } } else { /* ** In this case, we are at the end of data, but the "closing ** remarks" (no more strings (if gca) and null bytes) doesn't ** fit in the buffer. ** ** We mark this fact by setting the state to ADW_F_DONE_NEED_NULL. */ result_dv->db_length = work->adw_shared.shd_o_used; work->adw_fip.fip_state = ADW_F_DONE_NEED_NULL; adf_scb->adf_errcb.ad_errcode = E_AD0002_INCOMPLETE; status = E_DB_INFO; } return(status); }
/*{ ** Name: adu_rdm1_setup - Setup for Redeem an ADF_COUPON ** ** Description: ** This routine performs the initialization for the redeeming of ** a coupon. This amount primarily to initializing the ** ADP_LO_WKSP function instance private and shared (adw_fip & ** adw_shared, respectively). This routine also moves the ** appropriate peripheral header into the output area. ** ** Since this routine moves the peripheral header to the output ** area, in the case where the original call to this routine has ** insufficient space for the output header, this routine may be ** called more than once. We note this since it is "unusual" for ** the initialization routine to be called more than one time for ** an object. In the case where the original space is of ** insufficent size, then this routine will return an indication ** that the output area is full, and will move nothing into it. ** Thus, this routine considers it a call-protocol error to be ** called a second time with insufficient space. ** ** Inputs: ** adf_scb The session's control block (ptr). ** result_dv Pointer to DB_DATA_VALUE for ** result. ** coupon_dv Pointer to DB_DATA_VALUE ** describing the input coupon to ** be redeemed. ** workspace_dv Pointer to DB_DATA_VALUE ** describing redeem's workspace. ** continuation Continuation indicator. 0 ** indicates the first call, else ** not the first call. ** ** Outputs: ** adf_scb->adf_error Filled as appropriate. ** *result_dv->db_data Setup with beginning of peripheral ** data type. ** *workspace_dv->db_data Initialized for ongoing redeem work. ** Returns: ** DB_STATUS ** Exceptions: ** None. ** ** Side Effects: ** None. ** ** History: ** 02-dec-1992 (fred) ** Coded. Created from adu_redeem prototype in support of ** OME large objects. ** 8-Apr-1993 (fred) ** Fixed bug in zero length large object handling. For large ** objects of zero length which are not nullable, the length ** should not include the null-value-byte. ** 12-Oct-1993 (fred) ** Removed call to ADP_INFORMATION -- subsumed by ** adi_per_under(). ** 10-sep-1998 (schte01) ** Modified I4ASSIGN for axp_osf to pass the value, not the address ** of the value, to be assigned. This worked under the -oldc ** compiler option and got compile errors under -newc. ** 28-jul-1999 (thaju02) ** If the coupon stipulates that the data is not null, then ** the minimum result buffer length must be large enough to ** hold one byte of data along with all necessary info ** (ADP_HDR_SIZE + nextsegmarker(i4) + 2byteseglenindicator ** + 1byteofdata). Given a buffer with only 18 bytes of space ** available, 12 bytes are filled with peripheral header info ** in adu_rdm1_setup and 4 bytes are filled with the next ** segment marker in adu_redeem. In adc_lvch_xform, the 2 ** byte segment length indicator is initially set to zero ** in the result buffer. If there is no space left in the ** result buffer for segment data, we flush the buffer. In ** the front end, upon receiving this result buffer, the ** next segment marker indicates that there is data following, ** yet the length is zero; terminal monitor infinitely loops. ** (b98104) ** 12-aug-99 (stial01) ** adu_rdm1_setup() 'blob_work' arg to adi_per_under should be ** NULL before redeem. ** 24-may-2000 (stial01) ** adu_rdm1_setup() clear null indicator if not null (B101656) ** [@history_template@]... */ DB_STATUS static adu_rdm1_setup(ADF_CB *adf_scb, DB_DATA_VALUE *result_dv, DB_DATA_VALUE *coupon_dv, ADP_LO_WKSP *work, i4 for_gca) { DB_STATUS status; ADP_PERIPHERAL *p = (ADP_PERIPHERAL *) result_dv->db_data; DB_DT_ID dtid = ADI_DT_MAP_MACRO(abs(result_dv->db_datatype)); i4 min_size; bool isnull = 0; if (coupon_dv->db_datatype < 0) work->adw_fip.fip_null_bytes = 1; else work->adw_fip.fip_null_bytes = 0; if (ult_check_macro(&Adf_globs->Adf_trvect, ADF_011_RDM_TO_V_STYLE, &dummy1, &dummy2)) { work->adw_fip.fip_test_mode = 1; work->adw_fip.fip_test_length = ADP_TST_VLENGTH + work->adw_fip.fip_null_bytes; work->adw_fip.fip_test_sent = 0; } else { work->adw_fip.fip_test_mode = 0; } work->adw_shared.shd_exp_action = ADW_START; work->adw_fip.fip_done = FALSE; /* ** Fool the main routine into getting us an input segment. Make ** look like the input segement is all used up. */ work->adw_shared.shd_type = coupon_dv->db_datatype; work->adw_shared.shd_i_area = (char *) 0; work->adw_shared.shd_i_used = work->adw_shared.shd_i_length = 0; work->adw_shared.shd_o_used = ADP_HDR_SIZE; work->adw_shared.shd_o_length = result_dv->db_length; work->adw_shared.shd_o_area = (char *) result_dv->db_data; if (work->adw_shared.shd_o_length > MAXI2) { TRdisplay("adu_rdm1_setup shd_o_length %d MAX %d\n", work->adw_shared.shd_o_length, MAXI2); return(adu_error(adf_scb, E_AD9999_INTERNAL_ERROR, 0)); } work->adw_shared.shd_l0_check = work->adw_shared.shd_l1_check = 0; work->adw_fip.fip_pop_cb.pop_continuation = ADP_C_BEGIN_MASK; work->adw_fip.fip_pop_cb.pop_user_arg = (PTR) 0; work->adw_fip.fip_pop_cb.pop_type = (ADP_POP_TYPE); work->adw_fip.fip_pop_cb.pop_length = sizeof(ADP_POP_CB); work->adw_fip.fip_pop_cb.pop_ascii_id = ADP_POP_ASCII_ID; work->adw_fip.fip_pop_cb.pop_temporary = ADP_POP_PERMANENT; work->adw_fip.fip_pop_cb.pop_coupon = coupon_dv; work->adw_fip.fip_pop_cb.pop_segment = &work->adw_fip.fip_seg_dv; work->adw_fip.fip_pop_cb.pop_underdv = &work->adw_fip.fip_under_dv; status = adi_per_under(adf_scb, result_dv->db_datatype, &work->adw_fip.fip_under_dv); if (status) { return(adu_error(adf_scb, E_AD7000_ADP_BAD_INFO, 0)); } STRUCT_ASSIGN_MACRO(work->adw_fip.fip_under_dv, work->adw_fip.fip_seg_dv); work->adw_fip.fip_seg_dv.db_data = (char *) ((char *) work + sizeof(ADP_LO_WKSP)); if (ADI_ISNULL_MACRO(coupon_dv) || ((((ADP_PERIPHERAL *)coupon_dv->db_data)->per_length0 == 0) && (((ADP_PERIPHERAL *) coupon_dv->db_data)->per_length1 == 0))) isnull = 1; if (isnull) /* hdr + segment indicator + sizeof(null byte) */ min_size = ADP_HDR_SIZE + sizeof(i4) + work->adw_fip.fip_null_bytes; else /* hdr + segment indicator + segment length + segment single byte */ min_size = ADP_HDR_SIZE + sizeof(i4) + sizeof(i2) + sizeof(char); if (result_dv->db_length >= min_size) { if (for_gca) work->adw_shared.shd_out_tag = ADP_P_GCA; else work->adw_shared.shd_out_tag = ADP_P_DATA; I4ASSIGN_MACRO(work->adw_shared.shd_out_tag, p->per_tag); work->adw_shared.shd_out_segmented = (work->adw_shared.shd_out_tag != ADP_P_DATA); I4ASSIGN_MACRO( ((ADP_PERIPHERAL *) coupon_dv->db_data)->per_tag, work->adw_shared.shd_inp_tag); work->adw_shared.shd_inp_segmented = (work->adw_shared.shd_inp_tag != ADP_P_DATA); I4ASSIGN_MACRO( ((ADP_PERIPHERAL *) coupon_dv->db_data)->per_length0, p->per_length0); I4ASSIGN_MACRO(p->per_length0, work->adw_fip.fip_l0_value); I4ASSIGN_MACRO(((ADP_PERIPHERAL *) coupon_dv->db_data)->per_length1, p->per_length1); I4ASSIGN_MACRO(p->per_length1, work->adw_fip.fip_l1_value); work->adw_fip.fip_state = ADW_F_RUNNING; } else if (work->adw_fip.fip_state != ADW_F_STARTING) { work->adw_fip.fip_state = ADW_F_STARTING; result_dv->db_length = 0; adf_scb->adf_errcb.ad_errcode = E_AD0002_INCOMPLETE; return(E_DB_INFO); } else { return(adu_error(adf_scb, E_AD9999_INTERNAL_ERROR, 0)); } if (isnull) { if (work->adw_fip.fip_test_mode) { ((DB_TEXT_STRING *) p)->db_t_count = (i2) 0; if (result_dv->db_length >= (work->adw_fip.fip_test_length - work->adw_fip.fip_test_sent)) { result_dv->db_length = work->adw_fip.fip_test_length - work->adw_fip.fip_test_sent; work->adw_fip.fip_test_sent = work->adw_fip.fip_test_length; } else { work->adw_fip.fip_state = ADW_F_DONE_NEED_NULL; work->adw_fip.fip_test_sent += result_dv->db_length; adf_scb->adf_errcb.ad_errcode = E_AD0002_INCOMPLETE; return(E_DB_INFO); } } else { i4 zero = 0; /* ** Insert GCA mark that says there is no segment. */ #if defined(axp_osf) || defined(ris_u64) || defined(LP64) || \ defined(axp_lnx) /* ** We want to init the GCA field after the header, but ** on axp_osf this is not the same as the start of the ** coupon, because 8-byte alignment causes a slack 4-byte ** integer to be between the header and the coupon. See ** adu_redeem above for a different way this field is set ** to 1 when we have real data (not null). The addressing ** of this field should really be standardized in such a ** way that contiguous layout of 4-byte aligned fields is ** not assumed. */ I4ASSIGN_MACRO(zero,*((char *)p + ADP_HDR_SIZE)); #endif I4ASSIGN_MACRO(zero, p->per_value); result_dv->db_length = ADP_NULL_PERIPH_SIZE; if (work->adw_shared.shd_type > 0) result_dv->db_length -= 1; } if (ADI_ISNULL_MACRO(coupon_dv)) ADF_SETNULL_MACRO(result_dv); else ADF_CLRNULL_MACRO(result_dv); adf_scb->adf_errcb.ad_errcode = E_DB_OK; work->adw_fip.fip_done = TRUE; return(E_DB_OK); } if (work->adw_fip.fip_test_mode) { i4 segment_count; i4 length1; i2 count; I4ASSIGN_MACRO(p->per_length1, length1); I4ASSIGN_MACRO(p->per_length0, segment_count); if (!segment_count) segment_count = ADP_TST_SEG_CNT; count = min( ADP_TST_VLENGTH, (i2) (length1 + (segment_count * (sizeof(i4) + sizeof(i2))) + sizeof(i4) /* no more segments */ + work->adw_shared.shd_o_used) ) - sizeof(i2); I2ASSIGN_MACRO(count, ((DB_TEXT_STRING *) p)->db_t_count); } return(E_DB_OK); }