bool free_resources( errno_t in_errno )
{
if( in_errno == ENOMEM) g_err( err_no_memory );
else g_err( err_no_handles );
err_count++;
return( false );
}
uschar *
tls_cert_ext_by_oid(void * cert, uschar * oid, int idx)
{
uschar * cp1 = NULL;
uschar * cp2;
uschar * cp3;
size_t siz = 0;
unsigned int crit;
int ret;
ret = gnutls_x509_crt_get_extension_by_oid ((gnutls_x509_crt_t)cert,
oid, idx, cp1, &siz, &crit);
if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
return g_err("ge0", __FUNCTION__, ret);
cp1 = store_get(siz*4 + 1);
ret = gnutls_x509_crt_get_extension_by_oid ((gnutls_x509_crt_t)cert,
oid, idx, cp1, &siz, &crit);
if (ret < 0)
return g_err("ge1", __FUNCTION__, ret);
/* binary data, DER encoded */
/* just dump for now */
for(cp3 = cp2 = cp1+siz; cp1 < cp2; cp3 += 3, cp1++)
sprintf(cp3, "%.2x ", *cp1);
cp3[-1]= '\0';
return cp2;
}
static bool free_inc_fp( void )
{
inputcb * ip;
filecb * cb;
int rc;
ip = input_cbs;
while( ip != NULL ) { // as long as input stack is not empty
if( ip->fmflags & II_file ) { // if file (not macro)
if( (cb = ip->s.f) != NULL ) {
if( (cb->flags & FF_open) ) { // and file is open
rc = fgetpos( cb->fp, &cb->pos );
if( rc != 0 ) {
strerror_s( buff2, buf_size, errno );
g_err( err_file_io, buff2, cb->filename );
err_count++;
g_suicide();
}
rc = fclose( cb->fp );
if( rc != 0 ) {
strerror_s( buff2, buf_size, errno );
g_err( err_file_io, buff2, cb->filename );
err_count++;
g_suicide();
}
cb->flags &= ~FF_open;
return( true );
}
}
}
ip = ip->prev; // next higher input level
}
return( false ); // nothing to close
}
static void reopen_inc_fp( filecb *cb )
{
int rc;
errno_t erc;
errno_t erc2;
if( ! cb->flags & FF_open ) {
for( ;; ) {
erc = fopen_s( &cb->fp, cb->filename, "rb" );
if( erc == 0 ) break;
erc2 = errno;
if( errno != ENOMEM && errno != ENFILE && errno != EMFILE ) break;
if( !free_inc_fp() ) break; // try closing an include file
}
if( erc == 0 ) {
rc = fsetpos( cb->fp, &cb->pos );
if( rc != 0 ) {
strerror_s( buff2, buf_size, errno );
g_err( err_file_io, buff2, cb->filename );
err_count++;
g_suicide();
}
cb->flags |= FF_open;
} else {
strerror_s( buff2, buf_size, erc2 );
g_err( err_file_io, buff2, cb->filename );
err_count++;
g_suicide();
}
}
return;
}
void lay_widow( lay_tag ltag )
{
char * p;
condcode cc;
int k;
lay_att curr;
att_args l_args;
int cvterr;
ltag = ltag;
p = scan_start;
if( !GlobalFlags.firstpass ) {
scan_start = scan_stop;
eat_lay_sub_tag();
return; // process during first pass only
}
if( ProcFlags.lay_xxx != el_widow ) {
ProcFlags.lay_xxx = el_widow;
}
cc = get_lay_sub_and_value( &l_args ); // get one with value
while( cc == pos ) {
cvterr = -1;
for( k = 0, curr = widow_att[k]; curr > 0; k++, curr = widow_att[k] ) {
if( !strnicmp( att_names[curr], l_args.start[0], l_args.len[0] ) ) {
p = l_args.start[1];
switch( curr ) {
case e_threshold:
cvterr = i_uint8( p, curr, &layout_work.widow.threshold );
break;
default:
out_msg( "WGML logic error.\n");
cvterr = true;
break;
}
if( cvterr ) { // there was an error
err_count++;
g_err( err_att_val_inv );
file_mac_info();
}
break; // break out of for loop
}
}
if( cvterr < 0 ) {
err_count++;
g_err( err_att_name_inv );
file_mac_info();
}
cc = get_lay_sub_and_value( &l_args ); // get one with value
}
scan_start = scan_stop;
return;
}
void val_parse_err( const char * pa, bool tag )
{
err_count++;
if( tag ) {
g_err( err_inv_att_val );
} else {
g_err( err_inv_cw_op_val );
}
file_mac_info();
show_line_error( pa );
return;
}
void numb_err( void )
{
char linestr[MAX_L_AS_STR];
err_count++;
if( input_cbs->fmflags & II_macro ) {
ultoa( input_cbs->s.m->lineno, linestr, 10 );
g_err( ERR_PU_NUM, linestr, "macro", input_cbs->s.m->mac->name );
} else {
ultoa( input_cbs->s.f->lineno, linestr, 10 );
g_err( ERR_PU_NUM, linestr, "file", input_cbs->s.f->filename );
}
show_include_stack();
return;
}
void insert_page_width( doc_element * a_element )
{
uint32_t depth;
/* depth is used to update t_page.cur_depth and so must be kept separate */
if( !ProcFlags.page_started ) {
depth = a_element->top_skip;
ProcFlags.page_started = true;
} else {
depth = a_element->subs_skip;
}
depth += a_element->depth;
/****************************************************************/
/* Does the first line minimum apply here? If so, it needs to */
/* be implemented. Note that cur_el->depth does not reflect it */
/* because there is no way to tell if it will apply when the */
/* is computed. */
/****************************************************************/
switch( a_element->type ) {
// TOP FIG processing goes here
case el_text : // section heading: must go on t_page
if( (depth + t_page.cur_depth) <= t_page.max_depth ) {
if( t_page.page_width == NULL ) { // must be empty
t_page.page_width = a_element;
t_page.last_col_main = t_page.page_width;
t_page.cur_depth += depth;
if( bin_driver->y_positive == 0 ) {
t_page.main_top -= depth;
} else {
t_page.main_top += depth;
}
} else { // discard second section heading
g_err( err_intern, __FILE__, __LINE__ );
}
} else {
xx_err( err_heading_too_deep );
g_suicide(); // it won't fit on any page if not on this
}
break;
default:
g_err( err_intern, __FILE__, __LINE__ );
}
return;
}
void gml_index( gml_tag gtag )
{
gtag = gtag;
if( ProcFlags.doc_sect_nxt == doc_sect_egdoc ) {
xx_line_err( err_eof_expected, tok_start );
return;
}
if( ProcFlags.doc_sect_nxt == doc_sect_index ) {// duplicate :INDEX tag
scan_start = scan_stop; // ignore this call
return; // wgml4 OS/2 crashes with page fault
}
if( !((ProcFlags.doc_sect == doc_sect_backm) ||
(ProcFlags.doc_sect_nxt == doc_sect_backm)) ) {
xx_line_err( err_doc_sec_expected_1, tok_start );
return;
}
if( !GlobalFlags.index ) { // index option not active
g_err( wng_index_opt ); // give hint to activate index
scan_start = scan_stop;
return;
}
gml_doc_xxx( doc_sect_index );
gen_index(); // output the formatted index
}
void clear_doc_element( doc_element * element )
{
doc_element * cur_el;
text_line * cur_line;
text_line * save;
for( cur_el = element; cur_el != NULL; cur_el = cur_el->next ) {
switch( cur_el->type ) {
case el_binc :
case el_graph :
break; // should be nothing to do
case el_text :
cur_line = cur_el->element.text.first;
while( cur_line != NULL ) {
add_text_chars_to_pool( cur_line );
save = cur_line->next;
add_text_line_to_pool( cur_line );
cur_line = save;
}
break;
default :
g_err( err_intern, __FILE__, __LINE__ );
}
}
return;
}
void tag_name_missing_err( void )
{
err_count++;
g_err( err_missing_name, "" );
file_mac_info();
return;
}
void nottag_err( void )
{
err_count++;
g_err( err_user_tag, tagname );
file_mac_info();
return;
}
void parm_extra_err( char * cw, char * pa )
{
err_count++;
g_err( err_extra_ignored, cw, pa );
file_mac_info();
return;
}
void parm_miss_err( char *pa )
{
err_count++;
g_err( err_parm_missing, pa );
file_mac_info();
return;
}
void xx_tag_err( const msg_ids errid, char const * cw )
{
err_count++;
g_err( errid, cw );
file_mac_info();
return;
}
bool i_place( char * p, lay_att curr, bf_place * tm )
{
bool cvterr;
curr = curr;
cvterr = false;
if( !strnicmp( "topeven", p, 7 ) ) {
*tm = topeven_place;
} else if( !strnicmp( "bottom", p, 6 ) ) {
*tm = bottom_place;
} else if( !strnicmp( "inline", p, 6 ) ) {
*tm = inline_place;
} else if( !strnicmp( "topodd", p, 6 ) ) {
*tm = topodd_place;
} else if( !strnicmp( "top", p, 3 ) ) {// check for top later than topXXX
*tm = top_place;
} else if( !strnicmp( "botodd", p, 6 ) ) {
*tm = botodd_place;
} else if( !strnicmp( "boteven", p, 7 ) ) {
*tm = boteven_place;
} else {
err_count++;
g_err( err_att_val_inv );
file_mac_info();
cvterr = true;
}
return( cvterr );
}
bool i_pouring( char * p, lay_att curr, reg_pour * tm )
{
bool cvterr;
curr = curr;
cvterr = false;
if( !strnicmp( "none", p, 4 ) ) {
*tm = no_pour;
} else if( !strnicmp( "last", p, 4 ) ) {
*tm = last_pour;
} else if( !strnicmp( "head0", p, 5 ) ) {
*tm = head0_pour;
} else if( !strnicmp( "head1", p, 5 ) ) {
*tm = head1_pour;
} else if( !strnicmp( "head2", p, 5 ) ) {
*tm = head2_pour;
} else if( !strnicmp( "head3", p, 5 ) ) {
*tm = head3_pour;
} else if( !strnicmp( "head4", p, 5 ) ) {
*tm = head4_pour;
} else if( !strnicmp( "head5", p, 5 ) ) {
*tm = head5_pour;
} else if( !strnicmp( "head6", p, 5 ) ) {
*tm = head6_pour;
} else {
err_count++;
g_err( err_att_val_inv );
file_mac_info();
cvterr = true;
}
return( cvterr );
}
static void g_err_doc_sect( doc_section ds )
{
static char const sect[14][9] =
{ // same sequence as doc_section enum
"NONE",
"GDOC",
"FRONTM",
"TITLEP",
"eTITLEP",
"ABSTRACT",
"PREFACE",
"TOC",
"FIGLIST",
"BODY",
"APPENDIX",
"BACKM",
"INDEX",
"eGDOC"
};
err_count++;
scan_err = true;
g_err( err_doc_sect, sect[ds] );
file_mac_info();
}
void gml_sf( const gmltag * entry )
{
char * p;
char * pe;
long font;
p = scan_start;
p++;
while( *p == ' ' ) {
p++;
}
if( !strnicmp( "font=", p, 5 ) ) {
p += 5;
font = strtol( p, &pe, 10 );
scan_start = pe;
if( (font < 0) || (font >= wgml_font_cnt) ) {// invalid font use default
font = 0;
}
gml_hp_sf_common( entry, font, t_SF );
} else {
err_count++;
// AT-001 Required attribute not found
g_err( err_att_missing );
file_mac_info();
}
scan_start = scan_stop + 1;
return;
}
void xx_err( const msg_ids errid )
{
err_count++;
g_err( errid );
file_mac_info();
return;
}
static void get_macro_line( void )
{
macrocb * cb;
if( input_cbs->fmflags & II_file ) {// current input is file not macro
g_err( err_logic_mac );
show_include_stack();
err_count++;
g_suicide();
}
cb = input_cbs->s.m;
if( cb->macline == NULL ) { // no more macrolines
input_cbs->fmflags |= II_eof;
input_cbs->fmflags &= ~(II_sol | II_eol);
cb->flags |= FF_eof;
*buff2 = '\0';
} else {
cb->lineno++;
cb->flags &= ~FF_eof;
input_cbs->fmflags &= ~II_eof;
input_cbs->fmflags |= (II_sol | II_eol);
strcpy_s( buff2, buf_size, cb->macline->value );
cb->macline = cb->macline->next;
}
}
doc_element * alloc_doc_el( element_type type )
{
doc_element * curr;
doc_element * prev;
int k;
curr = doc_el_pool;
if( curr != NULL ) { // there is one to use
doc_el_pool = curr->next;
} else { // pool is empty
curr = mem_alloc( sizeof( doc_element ) );
doc_el_pool = mem_alloc( sizeof( *prev ) );
prev = doc_el_pool;
for( k = 0; k < 10; k++ ) { // alloc 10 doc_els if pool empty
prev->next = mem_alloc( sizeof( *prev ) );
prev = prev->next;
}
prev->next = NULL;
}
curr->next = NULL;
curr->blank_lines = 0;
curr->depth = 0;
curr->subs_skip = 0;
curr->top_skip = 0;
curr->type = type;
switch( type ) {
case el_binc :
curr->element.binc.cur_left = 0;
curr->element.binc.depth = 0;
curr->element.binc.y_address = 0;
curr->element.binc.at_top = false;
curr->element.binc.has_rec_type = false;
curr->element.binc.file[0] = '\0';
break;
case el_graph :
curr->element.graph.cur_left = 0;
curr->element.graph.depth = 0;
curr->element.graph.scale = 0;
curr->element.graph.width = 0;
curr->element.graph.y_address = 0;
curr->element.graph.xoff = 0;
curr->element.graph.yoff = 0;
curr->element.graph.at_top = false;
curr->element.graph.file[0] = '\0';
break;
case el_text :
curr->element.text.overprint = false;
curr->element.text.spacing = 0;
curr->element.text.first = NULL;
break;
default :
g_err( err_intern, __FILE__, __LINE__ );
}
return( curr );
}
void tag_text_req_err( char * tagname )
{
//****ERROR**** SC--039: Tag text must be specified with the 'xxx' tag
err_count++;
g_err( err_att_text_req, tagname );
file_mac_info();
return;
}
uschar *
tls_cert_subject(void * cert, uschar * mod)
{
uschar * cp = NULL;
int ret;
size_t siz = 0;
if ((ret = gnutls_x509_crt_get_dn(cert, cp, &siz))
!= GNUTLS_E_SHORT_MEMORY_BUFFER)
return g_err("gs0", __FUNCTION__, ret);
cp = store_get(siz);
if ((ret = gnutls_x509_crt_get_dn(cert, cp, &siz)) < 0)
return g_err("gs1", __FUNCTION__, ret);
return mod ? tls_field_from_dn(cp, mod) : cp;
}
void att_val_err( char * attname )
{
//****ERROR**** SC--045: Value 'xxx' for the 'yyy' attribute is not defined
err_count++;
g_err( err_att_val, token_buf, attname );
file_mac_info();
return;
}
void auto_att_err( void )
{
//****ERROR**** SC--041: Cannot specify the automatic attribute 'xxx'
err_count++;
g_err( err_auto_att, token_buf );
file_mac_info();
return;
}
void cw_err( void )
{
// SC--006: Unrecognized control word
err_count++;
g_err( err_cw_unrecognized, token_buf );
file_mac_info();
return;
}
void tag_text_err( char * tagname )
{
//****ERROR**** SC--038: Tag text may not be specified for the 'xxx' tag
err_count++;
g_err( err_att_text, tagname );
file_mac_info();
return;
}
void xx_line_err( const msg_ids errid, char *pa )
{
err_count++;
g_err( errid );
file_mac_info();
show_line_error( pa );
return;
}
void xx_opt_err( char *cw, char *pa )
{
err_count++;
g_err( err_xx_opt, cw, pa );
file_mac_info();
show_line_error( pa );
return;
}
