void CS_set_server_connect(char *listen_id) { i4 i; CS_find_server_slot(&i); STncpy( Cs_svinfo->csi_connect_id, listen_id, (sizeof(Cs_svinfo->csi_connect_id) - 1) ); Cs_svinfo->csi_connect_id[ sizeof(Cs_svinfo->csi_connect_id) - 1 ] = EOS; }
static STATUS my_dynamic_index(i4 msg, PTR cdata, i4 linstance, char *instance, PTR *instdata ) { STATUS stat = OK; i4 ival; char buf[ 20 ]; switch( msg ) { case MO_GET: *instdata = (PTR)instance; break; case MO_GETNEXT: if( *instance == EOS ) ival = 0; stat = CVal( instance, &ival ); /* value is the instance */ if( stat != OK ) break; if( ival > 9 ) /* validate this instance */ stat = MO_NO_INSTANCE; else if( ++ival > 9 ) /* validate next */ stat = MO_NO_NEXT; if( stat != OK ) break; CVla( ival, buf ); /* assumes caller doesn't blast instance before passing it to a get/set method. Otherwise hard to handle, because we don't want to allocate memory here to be freed in the get or set routine. */ *instdata = (PTR)instance; STncpy( instance, buf, linstance ); instance [ linstance ] = EOS; if( STlength( buf ) != STlen ( instance )) stat = MO_INSTANCE_TRUNCATED; break; default: stat = MO_BAD_MSG; } return( stat ); }
static STATUS my_dynamic_get( i4 offset, i4 objsize, PTR object, i4 luserbuf, char *userbuf ) { STATUS stat = OK; char *src = (char *)object; STncpy( userbuf, src, luserbuf ); userbuf[ luserbuf ] = EOS; if( STlength( src ) != STlen( userbuf )) stat = MO_VALUE_TRUNCATED; return( stat ); }
static STATUS mystrset( i4 offset, i4 luserbuf, char *userbuf, i4 objsize, PTR object ) { STATUS stat; STncpy( private_string, userbuf, sizeof( private_string ) ); private_string[ luserbuf ] = EOS; if( STlength( userbuf ) == STlen( private_string )) stat = OK; else stat = MO_VALUE_TRUNCATED; return( stat ); }
static STATUS mystrget( i4 offset, i4 objsize, PTR object, i4 luserbuf, char *userbuf ) { STATUS stat; STncpy( userbuf, private_string, luserbuf ); userbuf[ luserbuf ] = EOS; if( STlength( private_string ) == STlen( userbuf )) stat = OK; else stat = MO_VALUE_TRUNCATED; return( stat ); }
static STATUS myintget( i4 offset, i4 objsize, PTR object, i4 luserbuf, char *userbuf ) { STATUS stat = OK; char buf[ 20 ]; CVla( private_num, buf ); STncpy( userbuf, buf, luserbuf ) ; userbuf[ luserbuf ] = EOS; if( STlength( buf ) != STlength( userbuf ) ) stat = MO_VALUE_TRUNCATED; return( stat ); }
STATUS BS_tcp_addrinfo( char *buf, bool outbound, int ip_family, struct addrinfo **aiList ) { char *p; char port_zero[] = "0"; char hostname_buf[ MAXHOSTNAME ] = {0}; char *hostname = hostname_buf; int status; struct addrinfo hints; #if defined(axp_osf) struct addrinfo *aiList4 = NULL; struct addrinfo *last_ipv6_record, *ptr; bool no_ipv6_result = FALSE ; bool no_ipv4_result = FALSE ; #endif char gai_buf[1024]; /* set defaults */ MEfill(sizeof(struct addrinfo), 0, &hints); hints.ai_family = ip_family; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; hints.ai_flags = outbound ? 0 : AI_PASSIVE; /* parse address - look for a ";" */ for( p = buf; *p; p++ ) if( p[0] == ';' ) break; /* get hostname, if present */ if( *p ) { if( (p - buf) == 0 ) hostname = NULL; else { /* host;;port */ STncpy( hostname, buf, p - buf ); hostname[ p - buf ] = EOS; } } else hostname = NULL; /* now get port, if present - allow an extra ; */ if( p[0] == '\0' ) p = buf; else if( p[1] == ';' ) p = p + 2; else p = p + 1; if( CMdigit( p ) ) { /* 1234 port number */ if( !htons( (u_short)atoi( p ) ) && outbound) return BS_NOPORT_ERR; } else if( *p || outbound ) { return BS_NOPORT_ERR; } if( STlength( p ) == 0 ) /* Replace empty string for port with "0". */ p = port_zero; /* no obvious errors */ #if defined(axp_osf) if( outbound && (hostname != NULL) ) { status = getaddrinfo( hostname, p, &hints, aiList); if( status || !(*aiList)) return BS_NOHOST_ERR; } else { /* ** SegV or malloc error occurred on 5.1B with patch kit 6 ** if ai_family is AF_UNSPEC in getaddrinfo call. ** So make two calls (first IPv6,then IPv4), after the lists ** are retrieved, merge them into one list. */ hints.ai_family = AF_INET6; status = getaddrinfo( NULL, p, &hints, aiList ); if( status || !( *aiList )) no_ipv6_result = TRUE; hints.ai_family = AF_INET; status = getaddrinfo( NULL, p, &hints, &aiList4); if( status || !( aiList4 )) no_ipv4_result = TRUE; if( no_ipv6_result && no_ipv4_result ) return BS_NOHOST_ERR; if( aiList4 ) { if ( *aiList ) /* merge aiList and aiList4 if not NULL */ { for(ptr=*aiList; ptr; ptr=ptr->ai_next) last_ipv6_record = ptr; last_ipv6_record->ai_next = aiList4; } else *aiList = aiList4; } } #else /* if defined(axp_osf) */ status = getaddrinfo(outbound ? hostname : NULL, p, &hints, aiList); if( status || !(*aiList)) return BS_NOHOST_ERR; #endif /* if defined(axp_osf) */ return OK; }
STATUS BS_tcp_addr( char *buf, bool outbound, struct sockaddr_in *s ) { char *p; char hostname[ MAXHOSTNAME ]; struct hostent *hp; struct hostent host; struct hostent *iiCLgethostbyname(); # if defined(i64_hpu) struct hostent hostbuf; # elif defined(POSIX_THREADS) && defined(any_hpux) struct hostent_data hostbuf; # else union { # if defined(any_aix) struct hostent_data h; /* for alignment purposes only */ char buf[sizeof(struct hostent_data)+512]; /* temporary buffer */ # else struct hostent h; /* for alignment purposes only */ char buf[sizeof(struct hostent)+512]; /* temporary buffer */ # endif } hostbuf; # endif int local_errno; # if defined(POSIX_THREADS) && defined(any_hpux) && !defined(i64_hpu) hostbuf.current = NULL; # endif /* POSIX_THREADS && hp8_us5 */ # if defined(any_aix) MEfill( sizeof(hostbuf), 0, &hostbuf ); # endif /* set defaults */ s->sin_family = AF_INET; s->sin_addr.s_addr = outbound ? htonl(INADDR_LOOPBACK) : INADDR_ANY; s->sin_port = 0; /* parse address - look for a ";" */ for( p = buf; *p; p++ ) if( p[0] == ';' ) break; /* get hostname, if present */ if( *p ) { /* host;;port */ STncpy( hostname, buf, p - buf ); hostname[ p - buf ] = EOS; if( ( hp = iiCLgethostbyname( hostname, &host, &hostbuf, sizeof(hostbuf), &local_errno ) ) ) MEcopy(hp->h_addr, hp->h_length, (PTR)&s->sin_addr); else if( CMdigit( hostname ) ) { /* host id, e.g. 128.0.2.1 */ if( !( s->sin_addr.s_addr = inet_addr( hostname ) ) ) return BS_NOHOST_ERR; } else { return BS_NOHOST_ERR; } } /* now get port, if present - allow an extra ; */ if( p[0] == '\0' ) p = buf; else if( p[1] == ';' ) p = p + 2; else p = p + 1; if( CMdigit( p ) ) { /* 1234 port number */ s->sin_port = htons( (u_short)atoi( p ) ); } else if( *p || outbound ) { return BS_NOPORT_ERR; } /* no obvious errors */ return OK; }
STATUS dmf_get_srs( DB_SPATIAL_REF_SYS *db_srs, i4 *errcode) { DMT_SHW_CB srs_show; DMT_TBL_ENTRY srs_table; STATUS status; DML_SCB *scb; CS_SID sid; DMT_CB dmt_cb; DMR_CB dmr_cb; DMR_ATTR_ENTRY key, *kptr = &key; SRS_ROW row; CSget_sid(&sid); scb = GET_DML_SCB(sid); /* ** make sure we are have a transaction */ if (scb->scb_x_ref_count != 1) { *errcode = E_AD5603_NO_TRANSACTION; return E_DB_ERROR; } /* * First we need to grab spatial_ref_sys information */ MEfill(sizeof(DB_OWN_NAME), ' ', &srs_show.dmt_owner); MEfill(sizeof(DB_TAB_NAME), ' ', &srs_show.dmt_name); STncpy(srs_show.dmt_name.db_tab_name, "spatial_ref_sys", STlen("spatial_ref_sys")); STncpy(srs_show.dmt_owner.db_own_name, "$ingres", STlen("$ingres")); srs_show.type = DMT_SH_CB; srs_show.length = sizeof(DMT_SHW_CB); srs_show.dmt_session_id = sid; srs_show.dmt_db_id = (PTR) scb->scb_x_next->xcb_odcb_ptr; srs_show.dmt_flags_mask = DMT_M_NAME | DMT_M_TABLE; srs_show.dmt_char_array.data_address = (PTR) NULL; srs_show.dmt_char_array.data_in_size = 0; srs_show.dmt_char_array.data_out_size = 0; srs_show.dmt_table.data_address = (PTR) &srs_table; srs_show.dmt_table.data_in_size = sizeof(DMT_TBL_ENTRY); status = dmt_show(&srs_show); if(status != E_DB_OK) { //something went wrong *errcode = E_AD5604_SRS_NONEXISTENT; return status; } /* * Next open the spatial_ref_sys table */ MEfill(sizeof(DMT_CB), 0, (PTR) &dmt_cb); dmt_cb.type = DMT_TABLE_CB; dmt_cb.length = sizeof(DMT_CB); dmt_cb.dmt_db_id = (PTR) scb->scb_x_next->xcb_odcb_ptr; STRUCT_ASSIGN_MACRO(srs_table.tbl_id, dmt_cb.dmt_id); dmt_cb.dmt_flags_mask = 0; dmt_cb.dmt_lock_mode = DMT_IS; dmt_cb.dmt_update_mode = DMT_U_DIRECT; dmt_cb.dmt_mustlock = FALSE; dmt_cb.dmt_access_mode = DMT_A_READ; dmt_cb.dmt_char_array.data_in_size = 0; dmt_cb.dmt_sequence = 0; dmt_cb.dmt_tran_id = (PTR) scb->scb_x_next; status = dmt_open(&dmt_cb); if (status != E_DB_OK) { *errcode = E_AD5601_GEOSPATIAL_INTERNAL; return status; } /* * Let's set up for the actual gets */ dmr_cb.type = DMR_RECORD_CB; dmr_cb.length = sizeof(DMR_CB); dmr_cb.dmr_access_id = dmt_cb.dmt_record_access_id; dmr_cb.dmr_tid = 0; dmr_cb.dmr_q_fcn = NULL; dmr_cb.dmr_position_type = DMR_QUAL; kptr->attr_number = SRS_SRID_COL; kptr->attr_operator = DMR_OP_EQ; kptr->attr_value = (char *) &db_srs->srs_srid; dmr_cb.dmr_attr_desc.ptr_address = (PTR) &kptr; dmr_cb.dmr_attr_desc.ptr_in_count = 1; dmr_cb.dmr_attr_desc.ptr_size = sizeof (DMR_ATTR_ENTRY); dmr_cb.dmr_flags_mask = 0; status = dmr_position(&dmr_cb); if (status != E_DB_OK) { if (dmr_cb.error.err_code == E_DM0055_NONEXT) *errcode = E_AD5605_INVALID_SRID; else *errcode = E_AD5601_GEOSPATIAL_INTERNAL; dmt_close(&dmt_cb); return status; } dmr_cb.dmr_data.data_in_size = SRS_ROW_SIZE; dmr_cb.dmr_data.data_address = row; dmr_cb.dmr_flags_mask = DMR_NEXT; status = dmr_get(&dmr_cb); if (status != E_DB_OK) { if (dmr_cb.error.err_code == E_DM0055_NONEXT) { *errcode = E_AD5605_INVALID_SRID; } else { *errcode = E_AD5601_GEOSPATIAL_INTERNAL; } dmt_close(&dmt_cb); return status; } /* * If we get here we retrieved a row yay! */ MEcopy((row + SRS_AUTH_NAME_OFFSET), sizeof(db_srs->srs_auth_name), db_srs->srs_auth_name); db_srs->srs_auth_name[STlen(db_srs->srs_auth_name)] = '\0'; MEcopy((row + SRS_AUTH_ID_OFFSET), sizeof(i4), &db_srs->srs_auth_id); MEcopy((row + SRS_SRTEXT_OFFSET), sizeof(db_srs->srs_srtext), db_srs->srs_srtext); db_srs->srs_srtext[STlen(db_srs->srs_srtext)] = '\0'; MEcopy((row + SRS_PROJ4TEXT_OFFSET), sizeof(db_srs->srs_proj4text), db_srs->srs_proj4text); db_srs->srs_proj4text[STlen(db_srs->srs_proj4text)] = '\0'; /* * Must close the table when we're done */ status = dmt_close(&dmt_cb); if(status != E_DB_OK) { /* close failed?? */ *errcode = E_AD5601_GEOSPATIAL_INTERNAL; return status; } return E_DB_OK; }
/* ** Name: psq_store_text - store query text in a contiguous block of QSF memory ** ** Description: ** Copy contents of a query text chain (prepended, if necessary with RANGE ** statements) into a contiguous block of QSF memory. Caller may specify ** that the text be stored in DB_TEXT_STRING format by setting ** return_db_text_string to TRUE; otherwise the function will return a i4 ** followed by query text. ** ** Input: ** rngtab if non-NULL, range statements will be ** generated for all entries of the range table ** that are active (pss_used && pss_rgno >= 0); ** should be non-NULL only for QUEL queries ** header Pointer to chain header ** mstream Pointer to opened memory stream ** return_db_text_string if TRUE, function will store text in ** DB_TEXT_STRING format; otherwise it will store ** it a a i4 (length) followed by text ** ** Output: ** result query text in specified format ** err_blk Filled in if an error happens ** ** Side efects: ** allocates memory ** ** Returns: ** E_DB_{OK,ERROR} ** ** History: ** 09-jan-93 (andre) ** written ** 29-jul-2001 (toumi01) ** problem found doing i64_aix port: ** (u_char *)'\n' should be (uchar)'\n' ** (u_char *)'\0' should be (uchar)'\0' ** 26-Oct-2009 (coomi01) b122714 ** Move psq_store_text() declarator to pshparse.h and make it public here. ** 24-Jun-2010 (kschendel) b123775 ** Correct a call to trim-whitespace. */ DB_STATUS psq_store_text( PSS_SESBLK *sess_cb, PSS_USRRANGE *rngtab, PTR header, PSF_MSTREAM *mstream, PTR *result, bool return_db_text_string, DB_ERROR *err_blk) { DB_STATUS status; i4 i; PSQ_THEAD *hp = (PSQ_THEAD *) header; i4 size = hp->psq_tsize; PSQ_TEXT *tp; PSS_RNGTAB *rngvar; u_char *out; if (rngtab) { /* ** allocate enough space for range statements. each range statement ** looks like range of 'rngname' is 'tabname'\n. ** Thus, max space is 14+2*DB_MAX_NAME. */ for (i = 0, rngvar = rngtab->pss_rngtab; i < PST_NUMVARS; i++, rngvar++) { /* Only look at range vars that are being used */ if (rngvar->pss_used && rngvar->pss_rgno >= 0) { size += ( 14 /* "range of is \n" */ + psf_trmwhite(DB_TAB_MAXNAME, rngvar->pss_rgname) + psf_trmwhite(sizeof(DB_TAB_NAME), (char *) &rngvar->pss_tabname)); } } } if (return_db_text_string) { DB_TEXT_STRING *str; status = psf_malloc(sess_cb, mstream, size + sizeof(*str) - sizeof(u_char), result, err_blk); if (status != E_DB_OK) return (status); str = (DB_TEXT_STRING *) *result; /* ** store the total length of query text */ str->db_t_count = size; out = str->db_t_text; } else { /* Allocate a piece large enough for all the text + a i4 (count) */ status = psf_malloc(sess_cb, mstream, size + sizeof(i4), result, err_blk); if (status != E_DB_OK) return (status); out = (u_char *) *result; /* Copy the length into the buffer */ MEcopy((char *) &size, sizeof(size), (char *) out); out += sizeof(size); } /* Copy the pieces into the buffer; first put the range statements */ if (rngtab) { for (i = 0, rngvar = rngtab->pss_rngtab; i < PST_NUMVARS; i++, rngvar++) { /* Only look at range vars that are being used */ if (rngvar->pss_used && rngvar->pss_rgno >= 0) { i4 plen; STncpy( (char *)out, "range of ", 9); out += 9; /* add in range name */ plen = psf_trmwhite(DB_TAB_MAXNAME, rngvar->pss_rgname); STncpy( (char *)out, rngvar->pss_rgname, plen); out += plen; STncpy( (char *)out, " is ", 4); out += 4; plen = psf_trmwhite(DB_TAB_MAXNAME, rngvar->pss_tabname.db_tab_name); STncpy( (char *)out, (char *)&rngvar->pss_tabname, plen); out += plen; *out = (u_char)'\n'; out++; *out = (u_char)'\0'; } } } for (tp = hp->psq_first; tp != (PSQ_TEXT *) NULL; tp = tp->psq_next) { MEcopy((char *) tp->psq_tval, tp->psq_psize, (char *) out); out += tp->psq_psize; } return(E_DB_OK); }
STATUS ERslookup( i4 msg_number, CL_ERR_DESC *clerror, i4 flags, char *sqlstate, char *msg_buf, i4 msg_buf_size, i4 language, i4 *msg_length, CL_ERR_DESC *err_code, i4 num_param, ER_ARGUMENT *param ) { i4 erindex; /* index of ERmulti table */ i4 status; i4 length = 0; ER_ARGUMENT *p; ER_ARGUMENT hidden[CLE_INFO_ITEMS]; /* to access info in clerror */ char tempbuf[ER_MAX_LEN+ER_MAX_NAME+2]; i4 templen; char *p_msg_buf; char *p_tempbuf; SYSTIME stime; char langbuf[ER_MAX_LANGSTR]; EX_CONTEXT context; ER_SEMFUNCS *sems; #define D_WIDTH 23 #define F_WIDTH 20 #define X_WIDTH 18 /* Validate the parameters. */ if (msg_buf == 0 || msg_buf_size == 0 || msg_length == 0) { return (ER_BADPARAM); } if (language != -1 && ERlangstr(language,langbuf) != OK) { return (ER_BADLANGUAGE); } if (!(flags & ER_NAMEONLY)) { EXdump(msg_number,0); } /* Insert timestamp if requested. */ if (flags & ER_TIMESTAMP) { if (msg_buf_size < 21) { return (ER_TOOSMALL); } TMnow(&stime); TMstr(&stime,msg_buf); length = (i4)STlength(msg_buf); msg_buf[length++] = ' '; } /* ** if (clerror && msg_number) ** look up msg_number, optional parameters in clerror->moreinfo ** else if (clerror) ** { ** if (clerror->intern) ** look up clerror.intern, optional params in clerror->moreinfo ** if (clerror->callid) ** look up system error message ** } */ if (clerror) { if (msg_number) /* Look up message after system error */ { /* ** Set up an ER_ARGUMENT that references system-dependent ** information in `clerror', and point `param' at it. */ i4 i; for (i = 0; i < CLE_INFO_ITEMS; ++i) { /* "...all of whose members begin at offset 0..." (K&R) */ hidden[i].er_value = (PTR)&clerror->moreinfo[i].data._i4; hidden[i].er_size = clerror->moreinfo[i].size; } param = &hidden[0]; num_param = CLE_INFO_ITEMS; } else /* retrieve system-dependent error messages */ { i4 len; ER_ARGUMENT argv[3]; if (clerror->intern) /* look up internal CL error */ { i4 i; for (i = 0; i < CLE_INFO_ITEMS; ++i) { argv[i].er_value = (PTR)&clerror->moreinfo[i].data._i4; argv[i].er_size = clerror->moreinfo[i].size; } /* ** Don't timestamp on recursive call, since it's been done ** already (if requested). */ if ((status = ERslookup((i4) clerror->intern, (CL_ERR_DESC*) NULL, flags & ~ER_TIMESTAMP | ER_TEXTONLY, NULL, &msg_buf[length], msg_buf_size-length, language, &len, err_code, CLE_INFO_ITEMS, argv)) != OK) { return (status); } length += len; if (clerror->callid) msg_buf[length++] = '\n'; } if (clerror->callid) /* look up system error message text */ { DESCRIPTOR msg_desc; msg_desc.desc_length = sizeof(tempbuf) - 1; msg_desc.desc_value = tempbuf; if ((status = cer_sysgetmsg(clerror, &len, &msg_desc, err_code)) != OK) { return(status); } argv[0].er_size = argv[1].er_size = argv[2].er_size = ER_PTR_ARGUMENT; argv[0].er_value = (PTR)&clerror->errnum; argv[1].er_value = (PTR)ERNAME((i4) clerror->callid); argv[2].er_value = (PTR)tempbuf; if ((status = ERslookup(ER_UNIXERROR, (CL_ERR_DESC*) NULL, flags & ~ER_TIMESTAMP | ER_TEXTONLY, NULL, &msg_buf[length], msg_buf_size - length, language, &len,err_code, 3, argv)) != OK) { return (status); } length += len; } msg_buf[*msg_length = length] = EOS; return (OK); } } /* ** Check if error message file is already opened or not yet. ** First see if the language is initialized. If not, initialize ** it and the message files. ** If it is already opened, cer_fndindex function returns the index of ** ERmulti table that internal language code is parameter 'language'. ** If not yet, it returns '-1'. */ if (cer_issem(&sems)) { if (((sems->sem_type & MU_SEM) ? (*sems->er_p_semaphore)(&sems->er_mu_sem) : (*sems->er_p_semaphore)(1, &sems->er_sem)) != OK) { sems = NULL; } } if ((erindex = cer_fndindex(language)) == -1) { if ((status = cer_nxtindex(language,&erindex)) != OK) { /* Error in initializing the language */ if (sems) { if (sems->sem_type & MU_SEM) _VOID_ (*sems->er_v_semaphore)(&sems->er_mu_sem); else _VOID_ (*sems->er_v_semaphore)(&sems->er_sem); } return (status); } } /* If the error message file is not opened, open the message file. */ if (!cer_isopen(erindex,ER_SLOWSIDE)) { if ((status = cer_sinit(language,msg_number,erindex,err_code)) != OK) { if (sems) { if (sems->sem_type & MU_SEM) _VOID_ (*sems->er_v_semaphore)(&sems->er_mu_sem); else _VOID_ (*sems->er_v_semaphore)(&sems->er_sem); } return (status); } } /* If not open then just return. */ if (!cer_isopen(erindex,ER_SLOWSIDE)) { if (sems) { if (sems->sem_type & MU_SEM) _VOID_ (*sems->er_v_semaphore)(&sems->er_mu_sem); else _VOID_ (*sems->er_v_semaphore)(&sems->er_sem); } /* ** As internal file id is '0', openning file will fail. ** In her,return status 'ER_BADOPEN' to show open fail. */ return (ER_BADOPEN); } /* ** Search message string from file and set to buffer. ** Error status on system call set to 'err_code'. */ status = cer_sstr(msg_number, sqlstate, tempbuf, msg_buf_size - length, erindex, err_code, flags & ER_TEXTONLY? ER_GET : ER_LOOKUP); if (sems) { if (sems->sem_type & MU_SEM) _VOID_ (*sems->er_v_semaphore)(&sems->er_mu_sem); else _VOID_ (*sems->er_v_semaphore)(&sems->er_sem); } if (status != OK) { return (status); } /* ** Format the text with parameters into the callers buffer. ** The message is truncated if it will not fit. */ /* Insert part of name from temporary buffer to buffer */ status = OK; templen = (i4)STlength(tempbuf); p_msg_buf = &msg_buf[length]; p_tempbuf = tempbuf; if (!(flags & ER_TEXTONLY)) { while(*p_tempbuf != '\t') { CMcpyinc(p_tempbuf,p_msg_buf); } CMcpyinc(p_tempbuf,p_msg_buf); } /* ============================================ */ /* Copy text to message substituting arguments. */ /* -------------------------------------------- */ /* (But first, declare an exception handler to */ /* catch bad params that may access violate.) */ /* ============================================ */ if (EXdeclare(er_exhandler, &context)) { u_i4 res_len; u_i4 bytes_left_in_buf; bytes_left_in_buf = (u_i4)(msg_buf_size - (p_msg_buf - msg_buf)); res_len = STlen( STncpy(p_msg_buf, ERx("*** ERslookup() ERROR: Missing or bad parameter for this message. ***"), bytes_left_in_buf )); p_msg_buf[ bytes_left_in_buf - 1 ] = EOS; p_msg_buf += res_len; *msg_length = (i4)(p_msg_buf - msg_buf); EXdelete(); return (OK); } for( ;p_tempbuf - tempbuf < templen; CMnext(p_tempbuf)) { long number; u_long unumber; double fnumber; i4 i; i4 pnum; if ( (*p_tempbuf != '%') || (flags & ER_NOPARAM) ) { if ((p_msg_buf - msg_buf) >= msg_buf_size) break; CMcpychar(p_tempbuf,p_msg_buf); CMnext(p_msg_buf); continue; } if (p_tempbuf - tempbuf + 2 >= templen) continue; CMnext(p_tempbuf); if (*p_tempbuf == '!') { if ((p_msg_buf - msg_buf) + 3 >= msg_buf_size) continue; CMcpychar(ERx("\r"),p_msg_buf); CMnext(p_msg_buf); CMcpychar(ERx("\n"),p_msg_buf); CMnext(p_msg_buf); CMcpychar(ERx("\t"),p_msg_buf); CMnext(p_msg_buf); continue; } /* ** Only works for up to 10 parameters, and makes character set ** assumptions - should be fixed. */ if ( *p_tempbuf < '0' || *p_tempbuf > '9' ) { /* treat any other character as a literal */ if ((p_msg_buf - msg_buf) >= msg_buf_size) break; if ( *p_tempbuf != '%' ) { CMcpychar("%",p_msg_buf); CMnext(p_msg_buf); } CMcpychar(p_tempbuf,p_msg_buf); CMnext(p_msg_buf); continue; } pnum = *p_tempbuf - '0'; if (pnum >= num_param) { EXdelete(); return(ER_BADPARAM); } p = ¶m[pnum]; CMnext(p_tempbuf); switch (*p_tempbuf) { case 'd': /* Convert an integer into the buffer with width D_WIDTH */ if (p->er_size == ER_PTR_ARGUMENT) /* this is ptr to i4 */ number = *(i4 *)p->er_value; else if (p->er_size == 0) /* this is a i4 */ number = (i4)(SCALARP)p->er_value; else if (p->er_size == 1) number = *(i1 *)p->er_value; else if (p->er_size == 2) number = *(i2 *)p->er_value; else if (p->er_size == 4) number = *(i4 *)p->er_value; else if (p->er_size == 8) number = *(i8 *)p->er_value; else continue; if (p_msg_buf - msg_buf + D_WIDTH >= msg_buf_size) continue; if (p->er_size == 8) { CVla8(number, p_msg_buf); } else { CVla((i4)number, p_msg_buf); } while (*p_msg_buf) CMnext(p_msg_buf); continue; case 'u': /* Convert an integer into the buffer with width D_WIDTH */ if (p->er_size == ER_PTR_ARGUMENT) /* this is ptr to u_i4 */ number = *(u_i4 *)p->er_value; else if (p->er_size == 0) /* this is a u_i4 */ number = (u_i4)(SCALARP)p->er_value; else if (p->er_size == 1) number = *(u_i1 *)p->er_value; else if (p->er_size == 2) number = *(u_i2 *)p->er_value; else if (p->er_size == 4) number = *(u_i4 *)p->er_value; else if (p->er_size == 8) number = *(u_i8 *)p->er_value; else continue; if (p_msg_buf - msg_buf + D_WIDTH >= msg_buf_size) continue; if (p->er_size == 8) { CVula8(number, p_msg_buf); } else { CVula((u_i4)number, p_msg_buf); } while (*p_msg_buf) CMnext(p_msg_buf); continue; case 'f': { i2 res_width; /* Convert a float into the buffer with width F_WIDTH */ if (p->er_size == ER_PTR_ARGUMENT) /* Pointer to a double */ fnumber = *(double *)p->er_value; else if (p->er_size == 4) fnumber = *(f4 *)p->er_value; else if (p->er_size == 8) fnumber = *(f8 *)p->er_value; else continue; if (p_msg_buf - msg_buf + F_WIDTH >= msg_buf_size) continue; /* Always convert to 'e' format. */ CVfa(fnumber, (i4) 20, (i4) 5, 'e', '.', p_msg_buf, &res_width); p_msg_buf += F_WIDTH; continue; } case 'c': /* Convert a character array into buffer. */ if (p->er_value == 0) p->er_value = (PTR)ERx("<missing>"); if ((p->er_size == 0) || (p->er_size == ER_PTR_ARGUMENT)) { for (i = 0; ((char *)p->er_value)[i]; i++) ; p->er_size = i; } if (p_msg_buf - msg_buf + p->er_size >= msg_buf_size) continue; if (p->er_size > msg_buf_size - (p_msg_buf - msg_buf)) p->er_size = (i4)(msg_buf_size - (p_msg_buf - msg_buf)); /* p->er_size=STtrmwhite(p_msg_buf);*/ MEcopy(p->er_value, p->er_size, p_msg_buf); p->er_size = (i4)STtrmnwhite(p_msg_buf, p->er_size); p_msg_buf += p->er_size; continue; case 'x': /* Convert an integer into the buffer with width D_WIDTH */ if (p->er_size == ER_PTR_ARGUMENT) unumber = *(u_i4 *)p->er_value; else if (p->er_size == 0) unumber = (u_i4)(SCALARP)p->er_value; else if (p->er_size == 1) unumber = *(u_i1 *)p->er_value; else if (p->er_size == 2) unumber = *(u_i2 *)p->er_value; else if (p->er_size == 4) unumber = *(u_i4 *)p->er_value; else if (p->er_size == 8) unumber = *(u_i8 *)p->er_value; if (p_msg_buf - msg_buf + X_WIDTH >= msg_buf_size) continue; for (i = 8; --i >= 0; ) { /* {@fix_me@} ** This is *NOT* machine independent. This relys on an ** ASCII-like character set, where the digits '0'-'9' are ** contiguous and sequential, and the characters 'A'-'F' ** are contiguous and sequential. Both ASCII and EBCDIC ** happen to be this way. */ if ((*(p_msg_buf + i) = (unumber & 0x0f) + '0') > '9') *(p_msg_buf + i) += 'A' - '9' - 1; unumber >>= 4; } p_msg_buf += 8; continue; default: continue; } } *msg_length = (i4)(p_msg_buf - msg_buf); *p_msg_buf = EOS; EXdelete(); return (OK); }
i4 main( i4 argc, char * argv[]) { char c='\0'; char *tz_file=NULL; char *tz_name=NULL; char *tz_def; char tzname[TM_MAX_TZNAME+1]; char tzfile[MAX_LOC+1]; char ioptarg[MAX_LOC + 1]; char tz_pmvalue[MAX_LOC + 1]; char tz_pmname[MAX_LOC + 1]; char *p, *ip, *pm_value; char *tm_tztype; char chr='/'; char *out_file; i4 ioptind=1, i; char *tm_tztime; i4 timecnt, tempi, temptype, temptz; char buf[sizeof(TM_TZ_CB)+TM_MAX_TIMECNT*(sizeof(i4)+1)]; FILE *fid; LOCATION loc_root, tmp_loc; STATUS status=OK; TM_TZ_CB *tm_tz_cb; struct timevect time_v; appname = argv[0]; if( TMtz_getopt(argc, argv, "n:name:f:file", &ioptind, ioptarg, &c) == OK) { switch (c) { case 'f': tz_file = ioptarg; break; case 'n': tz_name = ioptarg; break; default: break; } } else { TMtz_usage(); PCexit(FAIL); } if( tz_file == NULL) { if( tz_name == NULL) { /* Get II_TIMEZONE_NAME value */ NMgtAt(ERx("II_TIMEZONE_NAME"), &tz_def); if (!tz_def || !(*tz_def)) { SIprintf("%s: %s_TIMEZONE_NAME is not set\n", appname, SystemVarPrefix); PCexit(FAIL); } STncpy(tzname, tz_def, TM_MAX_TZNAME); tzname[ TM_MAX_TZNAME ] = EOS; } else { STncpy(tzname, tz_name, TM_MAX_TZNAME); tzname[ TM_MAX_TZNAME ] = EOS; } PMinit(); if( PMload( NULL, (PM_ERR_FUNC *)NULL) != OK) { SIprintf("%s: Error loading PM %s_CONFIG/config.dat file\n", appname, SystemVarPrefix); PCexit(FAIL); } /* Get timezone file name */ STprintf( tz_pmname, ERx("%s.*.tz.%s"), SystemCfgPrefix, tzname); if( PMget( tz_pmname, &pm_value) != OK) { SIprintf("%s: Error locating %s in PM config.dat file\n", appname, tz_pmname); PCexit(FAIL); } do { if((status = NMloc(FILES, PATH, ERx("zoneinfo"), &loc_root)) != OK) break; #if defined(conf_BUILD_ARCH_32_64) && defined(BUILD_ARCH64) if((status = LOfaddpath(&loc_root, ERx("lp64"), &loc_root)) != OK) break; #endif #if defined(conf_BUILD_ARCH_64_32) && defined(BUILD_ARCH32) { /* ** Reverse hybrid support must be available in ALL ** 32bit binaries */ char *rhbsup; NMgtAt("II_LP32_ENABLED", &rhbsup); if ( (rhbsup && *rhbsup) && ( !(STbcompare(rhbsup, 0, "ON", 0, TRUE)) || !(STbcompare(rhbsup, 0, "TRUE", 0, TRUE)))) status = LOfaddpath(&loc_root, "lp32", &loc_root); } #endif /* reverse hybrid */ STcopy( pm_value, tz_pmvalue); /* ** Compose the directory path */ for( p = tz_pmvalue, ip = tz_pmvalue; (p = STchr(ip, chr)) != NULL;) { *p = EOS; if((status = LOfaddpath(&loc_root, ip, &loc_root)) != OK) break; ip = CMnext(p); } /* ** Add file name to the directory path */ if((status = LOfroms(FILENAME, ip, &tmp_loc)) != OK) break; status = LOstfile( &tmp_loc, &loc_root); } while( FALSE); if( status != OK) { SIprintf("%s: Error composing timezone file name for %s\n", appname, tz_pmvalue); PCexit(FAIL); } } else { STcopy("<unknown>", tzname); STncpy( tzfile, tz_file, MAX_LOC); tzfile[ MAX_LOC ] = EOS; if( LOfroms(FILENAME&PATH, tzfile, &loc_root) != OK) { SIprintf("%s: Error composing timezone file name for %s\n", appname, tz_pmvalue); PCexit(FAIL); } } /* ** Now open the timezone information file */ do { if((status = SIfopen( &loc_root, ERx("r"), SI_VAR, sizeof buf, &fid)) != OK) break; status = SIread(fid, sizeof buf, &i, buf); status = SIclose(fid); } while(FALSE); if( status != OK) { LOtos( &loc_root, &out_file); SIprintf("%s: Error opening %s for timezone %s\n", appname, out_file, tzname); PCexit(FAIL); } tm_tz_cb = (TM_TZ_CB *)&buf; I4ASSIGN_MACRO( tm_tz_cb->timecnt, timecnt); /* Make sure the input file has correct file size */ if( timecnt > TM_MAX_TIMECNT || timecnt < 0 || i != sizeof(TM_TZ_CB) + timecnt*(sizeof(i4)+1)) { LOtos( &loc_root, &out_file); SIprintf( "%s: Invalid file format for timezone file %s for timezone %s\n", appname, out_file, tzname); SIprintf( " File size: %d, Expected file size: %d, time periods: %d\n", i, sizeof(TM_TZ_CB) + timecnt*(sizeof(i4)+1), timecnt); PCexit(FAIL); } /* Now we are all set to display the content of timezone information file */ LOtos( &loc_root, &out_file); SIprintf("\n\n"); SIprintf("timezone name: %s\n", tzname); SIprintf("timezone file: %s\n", out_file); SIprintf("-------------------------------------"); SIprintf("-------------------------------------\n"); if(timecnt == 0) { I4ASSIGN_MACRO( tm_tz_cb->tzinfo[0].gmtoff, tempi); SIprintf(" Fixed GMT offset (secs): %d\n", tempi); } else { SIprintf("\tPeriod Begin"); SIprintf("\t\tGMT offset\n"); SIprintf("\t(YYYY_MM_DD HH:MM)"); SIprintf("\t(Minute)\n\n"); tm_tztype = buf + sizeof(TM_TZ_CB); tm_tztime = tm_tztype + timecnt; i=0; while( i < timecnt) { I4ASSIGN_MACRO( *tm_tztime, tempi); /* Adjust for timezone */ if( i == 0) temptype = (i4)tm_tztype[i+1]; else temptype = (i4)tm_tztype[i-1]; I4ASSIGN_MACRO( tm_tz_cb->tzinfo[temptype].gmtoff, temptz); /* Get real timezone */ tempi += temptz; temptype = (i4)tm_tztype[i]; I4ASSIGN_MACRO( tm_tz_cb->tzinfo[temptype].gmtoff, temptz); TMtz_cvtime( tempi, &time_v); SIprintf("\t%04d_%02d_%02d %02d:%02d\t%d\t%s\n", time_v.tm_year+1900, time_v.tm_mon+1, time_v.tm_mday, time_v.tm_hour, time_v.tm_min, temptz/60, tm_tz_cb->tzlabel + tm_tz_cb->tzinfo[temptype].abbrind); tm_tztime += sizeof(i4); i++; } } PCexit(OK); }