match_selreg(char *fname)
{
int i;
#ifdef USE_BSD_REG
char *err;
#else
regex_t reg;
#endif
for(i=0;i<SELREGN;i++) {
#ifdef USE_BSD_REG
if (err=re_comp(selreg[i])) {
error(err);
return 1;
}
if (re_exec(fname)) {
return 1;
}
#else
if (regcomp(®,selreg[i],0)) {
return 1;
}
if (!regexec(®,fname,0,0,0)) {
regfree(®);
return 1;
}
regfree(®);
#endif
}
return 0;
}
void
GetPostProc (char *line)
{
char *start, *finish;
if (post_proc)
{
Xfree (post_proc);
post_proc = NULL;
}
start = strchr (line, '\"');
finish = strrchr (line, '\"');
if (start != finish)
{
/* found a pattern */
*finish = '\0';
post_proc = Xstrdup (start + 1);
strcpy (start, finish + 1);
if (BooleanEnv (GetEnv ("verbatim"), 1) == 0)
{
char *s;
s = re_comp (post_proc);
if (s != NULL) /* no error msg returned */
{
Xfree (post_proc);
post_proc = NULL;
}
}
}
else if (start != NULL)
{
/* found a single speech mark. Delete It. */
strcpy (start, start + 1);
}
}
int
main (void)
{
const char *err;
size_t i;
int ret = 0;
#ifdef HAVE_MCHECK_H
mtrace ();
#endif
for (i = 0; i < 100; ++i)
{
err = re_comp ("a t.st");
if (err)
{
printf ("re_comp failed: %s\n", err);
ret = 1;
}
if (! re_exec ("This is a test."))
{
printf ("re_exec failed\n");
ret = 1;
}
}
return ret;
}
/*-------------------------------------------------------------------
* MatchPattern 04.24.90 GH
*
* Catch-all routine for pattern-matching. Directs the search through
* BM_Srch(), BYG_Srch() or strstr() depending on heuristics based
* on pattern content.
*-------------------------------------------------------------------
*/
BYTE *
MatchPattern( BYTE *pattern, BYTE *text, int text_len )
{
char *dstr; /* mostly for debugging */
BYTE *pmatch;
Debug("%s %s\n",pattern,igset[searchtype]);
if(dstr = strpbrk((char *)pattern,"#."))
{
re_comp( (char *) pattern, igset[searchtype] );
pmatch = (BYTE *) re_exec(text);
}
else
{
if(strlen(pattern) > 2)
pmatch = BM_Srch(pattern,text,text_len,
(BYTE *)igset[searchtype] );
else
{
pmatch = strstr( text, pattern );
beg_of_patt = pmatch;
end_of_patt = pmatch+1;
/*
** Move end_of_patt beyond ignore set characters
*/
while(strchr((char *)igset[searchtype],*end_of_patt))
end_of_patt++;
}
}
return( pmatch );
}/*
static int
eval_match_comp(N_tag tag, bool_node *lhs, bool_node *rhs)
{
int sts;
char *res;
char *str= get_strvalue(lhs);
char *pat = get_strvalue(rhs);
if (rhs->tag != N_pat) {
eval_error("match");
}
res = re_comp(pat);
if (res != NULL) {
/* should have been checked at lex stage */
/* => internal error */
eval_error(res);
}
sts = re_exec(str);
if (sts < 0) {
eval_error("re_exec");
}
switch(tag) {
case N_match: return sts;
case N_nmatch: return !sts;
default:
eval_error("match comparison");
}/*switch*/
}
LDAP_CALL
ldap_getfirstfilter( LDAPFiltDesc *lfdp, char *tagpat, char *value )
{
LDAPFiltList *flp;
if ( lfdp == NULL || tagpat == NULL || value == NULL ) {
return( NULL ); /* punt */
}
if ( lfdp->lfd_curvalcopy != NULL ) {
NSLDAPI_FREE( lfdp->lfd_curvalcopy );
NSLDAPI_FREE( lfdp->lfd_curvalwords );
}
NSLDAPI_FREE(lfdp->lfd_curval);
if ((lfdp->lfd_curval = nsldapi_strdup(value)) == NULL) {
return( NULL );
}
lfdp->lfd_curfip = NULL;
for ( flp = lfdp->lfd_filtlist; flp != NULL; flp = flp->lfl_next ) {
if ( re_comp( tagpat ) == NULL && re_exec( flp->lfl_tag ) == 1
&& re_comp( flp->lfl_pattern ) == NULL
&& re_exec( lfdp->lfd_curval ) == 1 ) {
lfdp->lfd_curfip = flp->lfl_ilist;
break;
}
}
if ( lfdp->lfd_curfip == NULL ) {
return( NULL );
}
if (( lfdp->lfd_curvalcopy = nsldapi_strdup( value )) == NULL ) {
return( NULL );
}
if ( break_into_words( lfdp->lfd_curvalcopy, flp->lfl_delims,
&lfdp->lfd_curvalwords ) < 0 ) {
NSLDAPI_FREE( lfdp->lfd_curvalcopy );
lfdp->lfd_curvalcopy = NULL;
return( NULL );
}
return( ldap_getnextfilter( lfdp ));
}
void testValues() {
f = 2;
char* result = re_comp(anystring());
//@ assert result == \null || \valid_read(result);
//@ assert f == 2;
//@ assert vacuous: \false;
}
int GetMagicRec(int Typ, int First)
{
int Eof = FALSE;
char *temp, mask[256];
FILE *FeM;
if (First)
MagicNr = 0;
temp = calloc(PATH_MAX, sizeof(char));
snprintf(temp, PATH_MAX, "%s/etc/magic.data", getenv("MBSE_ROOT"));
if ((FeM = fopen(temp, "r")) == NULL) {
Syslog('+', "Huh? No magic file? (%s)", temp);
free(temp);
return FALSE;
}
fread(&magichdr, sizeof(magichdr), 1, FeM);
do {
if (fseek(FeM, magichdr.hdrsize + (MagicNr * magichdr.recsize), SEEK_SET) != 0) {
WriteError("$Can't seek record %ld in %s", MagicNr, temp);
free(temp);
fclose(FeM);
return FALSE;
}
MagicNr++;
if (fread(&magic, magichdr.recsize, 1, FeM) == 1) {
if ((magic.Active) && (magic.Attrib == Typ) && (strcasecmp(magic.From, TIC.TicIn.Area) == 0)) {
memset(&mask, 0, sizeof(mask));
strcpy(mask, re_mask(magic.Mask, FALSE));
if ((re_comp(mask)) == NULL) {
if (re_exec(TIC.NewFile)) {
fclose(FeM);
free(temp);
return TRUE;
}
} else {
WriteError("Magic: re_comp(%s) failed", mask);
}
}
} else {
Eof = TRUE;
}
} while (!Eof);
free(temp);
fclose(FeM);
return FALSE;
}
/*
* === FUNCTION ======================================================================
* Name: uri_init_regex
* Description: Initilises the regular expresion that is used break up the FQP into a
* uri object. This function must be the first function called by the
* scheduler when it is initlizing the regular expersion object.
* =====================================================================================
*/
extern int
uri_init_regex( regexpr_t *re)
{
int err = 0;
err = re_init(re, RE_ID);
if( err == 0 ) {
err = re_comp( re, RE_ID, RE, 0, NULL);
}
return err;
}
LDAPFiltInfo *
ldap_getfirstfilter( LDAPFiltDesc *lfdp, char *tagpat, char *value )
{
LDAPFiltList *flp;
if ( lfdp->lfd_curvalcopy != NULL ) {
free( lfdp->lfd_curvalcopy );
free( lfdp->lfd_curvalwords );
}
lfdp->lfd_curval = value;
lfdp->lfd_curfip = NULL;
for ( flp = lfdp->lfd_filtlist; flp != NULL; flp = flp->lfl_next ) {
if ( re_comp( tagpat ) == NULL && re_exec( flp->lfl_tag ) == 1
&& re_comp( flp->lfl_pattern ) == NULL
&& re_exec( lfdp->lfd_curval ) == 1 ) {
lfdp->lfd_curfip = flp->lfl_ilist;
break;
}
}
if ( lfdp->lfd_curfip == NULL ) {
return( NULL );
}
if (( lfdp->lfd_curvalcopy = strdup( value )) == NULL ) {
return( NULL );
}
if ( break_into_words( lfdp->lfd_curvalcopy, flp->lfl_delims,
&lfdp->lfd_curvalwords ) < 0 ) {
free( lfdp->lfd_curvalcopy );
lfdp->lfd_curvalcopy = NULL;
return( NULL );
}
return( ldap_getnextfilter( lfdp ));
}
/*
- regcomp - compile regular expression
*/
int
regcomp(
regex_t *re,
const char *str,
int flags)
{
size_t len;
int f = flags;
if (f®_PEND) {
len = re->re_endp - str;
f &= ~REG_PEND;
} else {
len = strlen(str);
}
return re_comp(re, str, len, f);
}
bool
SelectObjectByName (int Type, char *Pattern, bool Flag)
{
bool changed = false;
#if defined(HAVE_REGCOMP)
#define REGEXEC(arg) (regexec_match_all(&compiled, (arg)))
int result;
regex_t compiled;
/* compile the regular expression */
result = regcomp (&compiled, Pattern, REG_EXTENDED | REG_ICASE);
if (result)
{
char errorstring[128];
regerror (result, &compiled, errorstring, 128);
Message (_("regexp error: %s\n"), errorstring);
regfree (&compiled);
return (false);
}
#else
#define REGEXEC(arg) (re_exec((arg)) == 1)
char *compiled;
/* compile the regular expression */
if ((compiled = re_comp (Pattern)) != NULL)
{
Message (_("re_comp error: %s\n"), compiled);
return (false);
}
#endif
/* loop over all visible objects with names */
if (Type & TEXT_TYPE)
ALLTEXT_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, text)
&& TEXT_IS_VISIBLE (PCB, layer, text)
&& text->TextString
&& REGEXEC (text->TextString)
&& TEST_FLAG (SELECTEDFLAG, text) != Flag)
{
AddObjectToFlagUndoList (TEXT_TYPE, layer, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
DrawText (layer, text, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->ElementOn && (Type & ELEMENT_TYPE))
ELEMENT_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element)
&& ((TEST_FLAG (ONSOLDERFLAG, element) != 0) == SWAP_IDENT
|| PCB->InvisibleObjectsOn)
&& TEST_FLAG (SELECTEDFLAG, element) != Flag)
{
String name = ELEMENT_NAME (PCB, element);
if (name && REGEXEC (name))
{
AddObjectToFlagUndoList (ELEMENT_TYPE, element, element, element);
ASSIGN_FLAG (SELECTEDFLAG, Flag, element);
PIN_LOOP (element);
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
}
END_LOOP;
PAD_LOOP (element);
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
}
END_LOOP;
ELEMENTTEXT_LOOP (element);
{
AddObjectToFlagUndoList (ELEMENTNAME_TYPE, element, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
}
END_LOOP;
DrawElementName (element, 0);
DrawElement (element, 0);
changed = true;
}
}
}
END_LOOP;
if (PCB->PinOn && (Type & PIN_TYPE))
ALLPIN_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element)
&& pin->Name && REGEXEC (pin->Name)
&& TEST_FLAG (SELECTEDFLAG, pin) != Flag)
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
DrawPin (pin, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->PinOn && (Type & PAD_TYPE))
ALLPAD_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element)
&& ((TEST_FLAG (ONSOLDERFLAG, pad) != 0) == SWAP_IDENT
|| PCB->InvisibleObjectsOn)
&& TEST_FLAG (SELECTEDFLAG, pad) != Flag)
if (pad->Name && REGEXEC (pad->Name))
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
DrawPad (pad, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->ViaOn && (Type & VIA_TYPE))
VIA_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, via)
&& via->Name
&& REGEXEC (via->Name) && TEST_FLAG (SELECTEDFLAG, via) != Flag)
{
AddObjectToFlagUndoList (VIA_TYPE, via, via, via);
ASSIGN_FLAG (SELECTEDFLAG, Flag, via);
DrawVia (via, 0);
changed = true;
}
}
END_LOOP;
#if defined(HAVE_REGCOMP)
#if !defined(sgi)
regfree (&compiled);
#endif
#endif
if (changed)
{
IncrementUndoSerialNumber ();
Draw ();
}
return (changed);
}
void Browser::searchBackward(char *text)
{
boolean wrap = FALSE;
boolean last_buf = FALSE;
boolean found = FALSE;
char *buf = (char *)CALLOC(this->page_size+1, sizeof(char));
long start_pos = XmTextGetInsertionPosition(this->text) + this->page_start;
if(start_pos < 0) start_pos = this->file_size;
long pos = start_pos;
long prev_pos;
long bufstart;
theIBMApplication->setBusyCursor(TRUE);
#if defined(HAVE_REGCOMP) && defined(HAVE_REGEX_H)
regex_t search_for;
ASSERT(regcomp(&search_for, text, REG_NOSUB) == 0);
#elif defined(HAVE_REGCOMP) && defined(HAVE_REGEXP_H)
char *search_for = (char *)regcomp(text);
ASSERT(search_for != NULL);
#elif defined(HAVE_REGCMP)
char *search_for = regcmp(text, NULL);
ASSERT(search_for != NULL);
#elif defined(HAVE_RE_COMP)
char *error_string = re_comp(text);
if(error_string)
WarningMessage("Couldn't compile regular expression! %s", error_string);
#endif
bufstart = start_pos - this->page_size;
if(bufstart < 0) bufstart = 0;
while(!wrap || pos >= start_pos)
{
//
// Read in a buffer
//
this->from->seekg((std::streampos)bufstart);
if(!this->from)
{
std::cerr << "Seekg failed in Browser::searchBackward()" << std::endl;
}
this->from->read(buf, this->page_size);
if(!this->from)
{
std::cerr << "Read failed in Browser::searchBackward()" << std::endl;
}
if(this->from->fail()) this->from->clear();
//
// Get the actual number of chars read in
//
int nread = this->from->gcount();
//
// And NULL terminate the string
//
buf[nread] = '\0';
//
// Convert non-printing chars to '.'
//
int i;
for(i = 0; i < nread; i++)
{
if(((!isprint(buf[i])) && (buf[i] != '\n') && (buf[i] !='\t') &&
(buf[i] != ' ')) || (!isascii(buf[i])))
buf[i] = '.';
}
int offset;
#if defined(HAVE_REGCOMP) && defined(HAVE_REGEX_H)
if (regexec(&search_for, buf, 0, NULL, 0) == 0)
{
found = 1;
for (i = STRLEN(buf)-1; i >= 0; i--)
if (regexec(&search_for, buf + i, 0, NULL, 0) != 0)
break;
offset = i + 1;
}
#elif defined(HAVE_REGCOMP) && defined(HAVE_REGEXP_H)
if (regexec((regexp *)search_for, buf))
{
found = 1;
for (i = STRLEN(buf)-1; i >= 0; i--)
if (! regexec((regexp *)search_for, buf + i ))
break;
offset = i + 1;
}
#elif defined(HAVE_REGCMP)
if (regex(search_for, buf))
{
found = 1;
for (i = STRLEN(buf)-1; i >= 0; i--)
if (! regex(search_for, buf + i ))
break;
offset = i + 1;
}
#elif defined(HAVE_RE_COMP)
if (re_exec(buf))
{
found = 1;
for (i = STRLEN(buf)-1; i >= 0; i--)
if (! re_exec(buf + i))
break;
offset = i + 1;
}
#else
if (strstr(text, buf))
{
found = 1;
for (i = STRLEN(buf)-1; i >= 0; i--)
if (! strstr(text, buf + i ))
break;
offset = i + 1;
}
#endif
pos = bufstart + offset;
if(!wrap)
{
if(pos >= start_pos)
{
break;
}
else
{
prev_pos = pos;
found = TRUE;
}
}
else
{
prev_pos = pos;
found = TRUE;
}
if(!found)
{
//
// "Loop" around on the search
//
if(bufstart != 0)
{
bufstart -= (int)(0.95*this->page_size);
if(bufstart < 0) bufstart = 0;
if(wrap)
{
if(bufstart < start_pos)
{
if(last_buf) break;
bufstart = start_pos;
last_buf = TRUE;
}
}
}
else
{
bufstart = this->file_size - this->page_size;
if(bufstart < 0) bufstart = 0;
pos = this->file_size;
if(wrap) break;
wrap = TRUE;
}
}
else
{
this->gotoByte(prev_pos);
break;
}
}
if(!found)
WarningMessage("Pattern not found");
#if defined(HAVE_REGCOMP) && defined(HAVE_REGEX_H)
regfree(&search_for);
#elif (defined(HAVE_REGCOMP) && defined(HAVE_REGEXP_H)) || defined(HAVE_REGCMP)
free(search_for);
#endif
FREE(buf);
theIBMApplication->setBusyCursor(FALSE);
}
LDAPFiltDesc *LDAP_CALL ldap_init_getfilter_buf(char *buf, long buflen) {
LDAPFiltDesc *lfdp;
LDAPFiltList *flp, *nextflp;
LDAPFiltInfo *fip, *nextfip;
char *errmsg, *tag, **tok;
int tokcnt, i;
if ((buf == NULL) || (buflen < 0) ||
(lfdp = (LDAPFiltDesc *)NSLDAPI_CALLOC(1, sizeof(LDAPFiltDesc))) ==
NULL) {
return (NULL);
}
flp = nextflp = NULL;
fip = NULL;
tag = NULL;
while (buflen > 0 &&
(tokcnt = nsldapi_next_line_tokens(&buf, &buflen, &tok)) > 0) {
switch (tokcnt) {
case 1: /* tag line */
if (tag != NULL) {
NSLDAPI_FREE(tag);
}
tag = tok[0];
NSLDAPI_FREE(tok);
break;
case 4:
case 5: /* start of filter info. list */
if ((nextflp = (LDAPFiltList *)NSLDAPI_CALLOC(
1, sizeof(LDAPFiltList))) == NULL) {
ldap_getfilter_free(lfdp);
return (NULL);
}
nextflp->lfl_tag = nsldapi_strdup(tag);
nextflp->lfl_pattern = tok[0];
if ((errmsg = re_comp(nextflp->lfl_pattern)) != NULL) {
char msg[512];
ldap_getfilter_free(lfdp);
snprintf(msg, sizeof(msg), "bad regular expression \"%s\" - %s\n",
nextflp->lfl_pattern, errmsg);
ber_err_print(msg);
nsldapi_free_strarray(tok);
return (NULL);
}
nextflp->lfl_delims = tok[1];
nextflp->lfl_ilist = NULL;
nextflp->lfl_next = NULL;
if (flp == NULL) { /* first one */
lfdp->lfd_filtlist = nextflp;
} else {
flp->lfl_next = nextflp;
}
flp = nextflp;
fip = NULL;
for (i = 2; i < 5; ++i) {
tok[i - 2] = tok[i];
}
/* fall through */
case 2:
case 3: /* filter, desc, and optional search scope */
if (nextflp != NULL) { /* add to info list */
if ((nextfip = (LDAPFiltInfo *)NSLDAPI_CALLOC(
1, sizeof(LDAPFiltInfo))) == NULL) {
ldap_getfilter_free(lfdp);
nsldapi_free_strarray(tok);
return (NULL);
}
if (fip == NULL) { /* first one */
nextflp->lfl_ilist = nextfip;
} else {
fip->lfi_next = nextfip;
}
fip = nextfip;
nextfip->lfi_next = NULL;
nextfip->lfi_filter = tok[0];
nextfip->lfi_desc = tok[1];
if (tok[2] != NULL) {
if (strcasecmp(tok[2], "subtree") == 0) {
nextfip->lfi_scope = LDAP_SCOPE_SUBTREE;
} else if (strcasecmp(tok[2], "onelevel") == 0) {
nextfip->lfi_scope = LDAP_SCOPE_ONELEVEL;
} else if (strcasecmp(tok[2], "base") == 0) {
nextfip->lfi_scope = LDAP_SCOPE_BASE;
} else {
nsldapi_free_strarray(tok);
ldap_getfilter_free(lfdp);
return (NULL);
}
NSLDAPI_FREE(tok[2]);
tok[2] = NULL;
} else {
nextfip->lfi_scope = LDAP_SCOPE_SUBTREE; /* default */
}
nextfip->lfi_isexact =
(strchr(tok[0], '*') == NULL && strchr(tok[0], '~') == NULL);
NSLDAPI_FREE(tok);
}
break;
default:
nsldapi_free_strarray(tok);
ldap_getfilter_free(lfdp);
return (NULL);
}
}
if (tag != NULL) {
NSLDAPI_FREE(tag);
}
return (lfdp);
}
/*
* Delete a file
*/
void Delete(int UnDel, int Area, char *File)
{
char mask[256];
int rc = FALSE;
struct _fdbarea *fdb_area = NULL;
if (UnDel)
IsDoing("Undelete file");
else
IsDoing("Delete file");
ftnd_colour(LIGHTRED, BLACK);
/*
* Check area
*/
if (LoadAreaRec(Area) == FALSE) {
WriteError("Can't load record %d", Area);
die(FTNERR_INIT_ERROR);
}
if (!area.Available) {
WriteError("Area %d not available", Area);
if (!do_quiet)
printf("Area %d not available\n", Area);
die(FTNERR_CONFIG_ERROR);
}
if ((fdb_area = ftnddb_OpenFDB(Area, 30)) == NULL)
die(FTNERR_GENERAL);
ftnd_colour(CYAN, BLACK);
strcpy(mask, re_mask(File, FALSE));
if (re_comp(mask))
die(FTNERR_GENERAL);
while (fread(&fdb, fdbhdr.recsize, 1, fdb_area->fp) == 1) {
if (re_exec(fdb.LName) || re_exec(fdb.Name)) {
if (UnDel && fdb.Deleted) {
fdb.Deleted = FALSE;
Syslog('+', "Marked file %s in area %d for undeletion", fdb.Name, Area);
if (!do_quiet)
printf("Marked file %s in area %d for undeletion\n", fdb.Name, Area);
rc = TRUE;
}
if (!UnDel && !fdb.Deleted) {
fdb.Deleted = TRUE;
Syslog('+', "Marked file %s in area %d for deletion", fdb.Name, Area);
if (!do_quiet)
printf("Marked file %s in area %d for deletion\n", fdb.Name, Area);
rc = TRUE;
}
if (rc) {
if (ftnddb_LockFDB(fdb_area, 30)) {
fseek(fdb_area->fp, - fdbhdr.recsize, SEEK_CUR);
fwrite(&fdb, fdbhdr.recsize, 1, fdb_area->fp);
ftnddb_UnlockFDB(fdb_area);
} else {
rc = FALSE;
}
}
}
}
ftnddb_CloseFDB(fdb_area);
if (!rc) {
Syslog('+', "%selete %s in area %d failed", UnDel?"Und":"D", File, Area);
if (!do_quiet)
printf("%selete %s in area %d failed\n", UnDel?"Und":"D", File, Area);
}
}
int ascanf_strcmp ( ASCB_ARGLIST )
{ ASCB_FRAME_SHORT
ascanf_Function *s1, *s2;
set_NaN(*result);
ascanf_arg_error= 0;
if( !args || ascanf_arguments< 2 ){
ascanf_arg_error= 1;
}
else{
if( !(s1= parse_ascanf_address(args[0], 0, "ascanf_strcmp", (int) ascanf_verbose, NULL )) ||
(s1->type== _ascanf_procedure || s1->type== _ascanf_function || !s1->usage)
){
if( s1 ){
fprintf( StdErr, " (warning: 1st argument [%s=%s,\"%s\"] is not a valid string)== ",
s1->name, ad2str( s1->value, d3str_format, 0), (s1->usage)? s1->usage : "<NULL>"
);
}
else{
fprintf( StdErr, " (warning: 1st argument is NULL)== " );
}
}
if( !(s2= parse_ascanf_address(args[1], 0, "ascanf_strcmp", (int) ascanf_verbose, NULL )) ||
(s2->type== _ascanf_procedure || s2->type== _ascanf_function || !s2->usage)
){
if( s2 ){
fprintf( StdErr, " (warning: 2nd argument [%s=%s,\"%s\"] is not a valid string)== ",
s2->name, ad2str( s2->value, d3str_format, 0), (s2->usage)? s2->usage : "<NULL>"
);
}
else{
fprintf( StdErr, " (warning: 2nd argument is NULL)== " );
}
}
if( s1 && s2 && s1->usage && s2->usage ){
if( strncmp( s2->usage, "RE^", 3)== 0 && s2->usage[ strlen(s2->usage)-1]== '$' ){
char *c;
if( (c= re_comp( &(s2->usage[2]) )) ){
ascanf_emsg= c;
}
else{
*result= !re_exec( s1->usage );
}
}
else{
if( ascanf_arguments> 2 ){
if( args[2]< 0 ){
*result= strncmp( s1->usage, s2->usage, strlen(s2->usage) );
}
else{
*result= strncmp( s1->usage, s2->usage, (int) args[2] );
}
}
else{
*result= strcmp( s1->usage, s2->usage );
}
}
}
else{
set_Inf(*result, 1);
}
}
return(!ascanf_arg_error);
}
/*
* Search for a file, called from the menu.
*/
int FilenameScan()
{
FILE *pAreas;
int Found, Count = 0;
char mask[256];
char *Name;
_Tag T;
unsigned int OldArea;
struct _fdbarea *fdb_area = NULL;
Name = calloc(81, sizeof(char));
OldArea = iAreaNumber;
iLineCount = 2; /* Reset Line Counter to Zero */
arecno = 1; /* Reset Area Number to One */
Enter(2);
/* Accepts wildcards such as : *.zip, *.gz, *.* */
pout(WHITE, BLACK, (char *) Language(269));
Enter(2);
/* Enter filename to search for : */
pout(LIGHTCYAN, BLACK, (char *) Language(271));
colour(CFG.InputColourF, CFG.InputColourB);
GetstrC(Name, 80);
if ((strcmp(Name, "")) == 0) {
free(Name);
return 0;
}
strcpy(mask, re_mask(Name, TRUE));
Syslog('+', "FilenameScan(): \"%s\" -> \"%s\"", Name, mask);
free(Name);
re_comp(mask);
clear();
/* File Search by Filename */
pout(WHITE, BLACK, (char *) Language(272));
Enter(1);
InitTag();
if ((pAreas = OpenFareas(FALSE)) == NULL)
return 0;
while (fread(&area, areahdr.recsize, 1, pAreas) == 1) {
if ((Access(exitinfo.Security, area.LTSec)) && (area.Available) && (strlen(area.Password) == 0)) {
if ((fdb_area = mbsedb_OpenFDB(arecno, 30))) {
Found = FALSE;
Sheader();
Nopper();
while (fread(&fdb, fdbhdr.recsize, 1, fdb_area->fp) == 1) {
if (re_exec(fdb.Name) || re_exec(fdb.LName)) {
if (!Found) {
Enter(2);
if (iLC(2) == 1) {
SetFileArea(OldArea);
return 1;
}
Found = TRUE;
}
memset(&T, 0, sizeof(T));
T.Area = arecno;
T.Active = FALSE;
T.Size = fdb.Size;
strncpy(T.SFile, fdb.Name, 12);
strncpy(T.LFile, fdb.LName, 81);
SetTag(T);
Count++;
if (ShowOneFile() == 1) {
SetFileArea(OldArea);
return 1;
}
}
} /* End of while */
mbsedb_CloseFDB(fdb_area);
if (Found) {
Enter(2);
if (iLC(2) == 1) {
SetFileArea(OldArea);
return 1;
}
}
} /* End Check for LTSec */
} /* if access */
arecno++; /* Go to next file area */
} /* End of Main */
Syslog('+', "Found %d files", Count);
fclose(pAreas);
Enter(1);
if (Count)
Mark();
else
Pause();
SetFileArea(OldArea);
return 1;
}
LDAPFiltDesc *
ldap_init_getfilter_buf( char *buf, long buflen )
{
LDAPFiltDesc *lfdp;
LDAPFiltList *flp, *nextflp;
LDAPFiltInfo *fip, *nextfip;
char *tag, **tok;
int tokcnt, i;
if (( lfdp = (LDAPFiltDesc *)calloc( 1, sizeof( LDAPFiltDesc))) == NULL ) {
return( NULL );
}
flp = nextflp = NULL;
fip = NULL;
tag = NULL;
while ( buflen > 0 && ( tokcnt = next_line_tokens( &buf, &buflen, &tok ))
> 0 ) {
switch( tokcnt ) {
case 1: /* tag line */
if ( tag != NULL ) {
free( tag );
}
tag = tok[ 0 ];
free( tok );
break;
case 4:
case 5: /* start of filter info. list */
if (( nextflp = (LDAPFiltList *)calloc( 1, sizeof( LDAPFiltList )))
== NULL ) {
ldap_getfilter_free( lfdp );
return( NULL );
}
nextflp->lfl_tag = strdup( tag );
nextflp->lfl_pattern = tok[ 0 ];
if ( re_comp( nextflp->lfl_pattern ) != NULL ) {
#ifndef NO_USERINTERFACE
ldap_getfilter_free( lfdp );
fprintf( stderr, "bad regular expresssion %s\n",
nextflp->lfl_pattern );
#if !defined( MACOS ) && !defined( DOS ) && !defined(PGPSOCKETSLDAP) /* jason */
errno = EINVAL;
#endif
#endif /* NO_USERINTERFACE */
free_strarray( tok );
return( NULL );
}
nextflp->lfl_delims = tok[ 1 ];
nextflp->lfl_ilist = NULL;
nextflp->lfl_next = NULL;
if ( flp == NULL ) { /* first one */
lfdp->lfd_filtlist = nextflp;
} else {
flp->lfl_next = nextflp;
}
flp = nextflp;
fip = NULL;
for ( i = 2; i < 5; ++i ) {
tok[ i - 2 ] = tok[ i ];
}
/* fall through */
case 2:
case 3: /* filter, desc, and optional search scope */
if ( nextflp != NULL ) { /* add to info list */
if (( nextfip = (LDAPFiltInfo *)calloc( 1,
sizeof( LDAPFiltInfo ))) == NULL ) {
ldap_getfilter_free( lfdp );
free_strarray( tok );
return( NULL );
}
if ( fip == NULL ) { /* first one */
nextflp->lfl_ilist = nextfip;
} else {
fip->lfi_next = nextfip;
}
fip = nextfip;
nextfip->lfi_next = NULL;
nextfip->lfi_filter = tok[ 0 ];
nextfip->lfi_desc = tok[ 1 ];
if ( tok[ 2 ] != NULL ) {
if ( strcasecmp( tok[ 2 ], "subtree" ) == 0 ) {
nextfip->lfi_scope = LDAP_SCOPE_SUBTREE;
} else if ( strcasecmp( tok[ 2 ], "onelevel" ) == 0 ) {
nextfip->lfi_scope = LDAP_SCOPE_ONELEVEL;
} else if ( strcasecmp( tok[ 2 ], "base" ) == 0 ) {
nextfip->lfi_scope = LDAP_SCOPE_BASE;
} else {
free_strarray( tok );
ldap_getfilter_free( lfdp );
#if !defined( MACOS ) && !defined( DOS ) && !defined(PGPSOCKETSLDAP) /* jason */
errno = EINVAL;
#endif
return( NULL );
}
free( tok[ 2 ] );
tok[ 2 ] = NULL;
} else {
nextfip->lfi_scope = LDAP_SCOPE_SUBTREE; /* default */
}
nextfip->lfi_isexact = ( strchr( tok[ 0 ], '*' ) == NULL &&
strchr( tok[ 0 ], '~' ) == NULL );
free( tok );
}
break;
default:
free_strarray( tok );
ldap_getfilter_free( lfdp );
#if !defined( MACOS ) && !defined( DOS ) && !defined(PGPSOCKETSLDAP) /* jason */
errno = EINVAL;
#endif
return( NULL );
}
}
if ( tag != NULL ) {
free( tag );
}
return( lfdp );
}
void runSuccess() {
re_comp(anystring());
}
void Browser::searchForward(char *text)
{
boolean wrap = FALSE;
boolean found = FALSE;
char *buf = (char *)CALLOC(this->page_size+1, sizeof(char));
int i;
long start_pos =
1 + XmTextGetInsertionPosition(this->text) + this->page_start;
if(start_pos >= this->file_size) start_pos = 0;
long pos = start_pos;
theIBMApplication->setBusyCursor(TRUE);
#if defined(HAVE_REGCOMP) && defined(HAVE_REGEX_H)
regex_t search_for;
ASSERT(regcomp(&search_for, text, REG_NOSUB) == 0);
#elif defined(HAVE_REGCOMP) && defined(HAVE_REGEXP_H)
char *search_for = (char *)regcomp(text);
ASSERT(search_for != NULL);
#elif defined(HAVE_REGCMP)
char *search_for = regcmp(text, NULL);
ASSERT(search_for != NULL);
#elif defined(HAVE_RE_COMP)
char *error_string = re_comp(text);
if(error_string)
WarningMessage("Couldn't compile regular expression! %s", error_string);
#endif
while(!found && !wrap || pos < start_pos)
{
//
// Read in a buffer
//
this->from->seekg((std::streampos)pos);
if(!this->from)
{
std::cerr << "Seekg failed in Browser::searchForward()" << std::endl;
}
this->from->read(buf, this->page_size);
if(!this->from)
{
std::cerr << "Read failed in Browser::searchForward()" << std::endl;
}
if(this->from->fail()) this->from->clear();
//
// Get the actual number of chars read in
//
int nread = this->from->gcount();
//
// And NULL terminate the string
//
buf[nread] = '\0';
//
// Convert non-printing chars to '.'
//
for(i = 0; i < nread; i++)
{
if(((!isprint(buf[i])) && (buf[i] != '\n') && (buf[i] !='\t') &&
(buf[i] != ' ')) || (!isascii(buf[i])))
buf[i] = '.';
}
int offset;
#if defined(HAVE_REGCOMP) && defined(HAVE_REGEX_H)
int i;
for (i = 0; i < STRLEN(buf); i++)
if (regexec(&search_for, buf + i, 0, NULL, 0) != 0)
break;
if (i)
{
offset = i - 1;
found = 1;
}
#elif defined(HAVE_REGCOMP) && defined(HAVE_REGEXP_H)
int i;
for (i = 0; i < STRLEN(buf); i++)
if (! regexec((regexp *)search_for, buf + i ))
break;
if (i)
{
offset = i - 1;
found = 1;
}
#elif defined(HAVE_REGCMP)
extern char *__loc1;
if (regex(search_for, buf))
{
offset = __loc1 - buf;
found = 1;
}
#elif defined(HAVE_RE_COMP)
int i;
for (i = 0; i < STRLEN(buf); i++)
if (! re_exec(buf + i))
break;
if (i)
{
offset = i - 1;
found = 1;
}
#else
char *s;
s = strstr(text, buf);
if (s)
{
offset = s - buf;
found = 1;
}
#endif
if(found)
{
this->gotoByte(offset);
found = TRUE;
break;
}
else
{
int nread = this->from->gcount();
//
// "Loop" around on the search
//
if(nread == this->page_size)
{
pos += (int)(0.95*this->page_size);
}
else
{
// If we have already wrapped, break out.
if(wrap)
break;
else
pos = 0;
wrap = TRUE;
}
}
}
if(!found)
WarningMessage("Pattern not found");
#if defined(HAVE_REGCOMP) && defined(HAVE_REGEX_H)
regfree(&search_for);
#elif (defined(HAVE_REGCOMP) && defined(HAVE_REGEXP_H)) || defined(HAVE_REGCMP)
free(search_for);
#endif
FREE(buf);
theIBMApplication->setBusyCursor(FALSE);
}
int
main(int argc, char **argv)
{
typedef enum {
YOW, FETCH, STORE, DELETE, SCAN, REGEXP
} commands;
char opt;
int flags;
int giveusage = 0;
int verbose = 0;
commands what = YOW;
char *comarg[3];
int st_flag = DBM_INSERT;
int argn;
DBM *db;
datum key;
datum content;
flags = O_RDWR;
argn = 0;
while ((opt = getopt(argc, argv, "acdfFm:rstvx")) != ':') {
switch (opt) {
case 'a':
what = SCAN;
break;
case 'c':
flags |= O_CREAT;
break;
case 'd':
what = DELETE;
break;
case 'f':
what = FETCH;
break;
case 'F':
what = REGEXP;
break;
case 'm':
flags &= ~(000007);
if (strcmp(optarg, "r") == 0)
flags |= O_RDONLY;
else if (strcmp(optarg, "w") == 0)
flags |= O_WRONLY;
else if (strcmp(optarg, "rw") == 0)
flags |= O_RDWR;
else {
fprintf(stderr, "Invalid mode: \"%s\"\n", optarg);
giveusage = 1;
}
break;
case 'r':
st_flag = DBM_REPLACE;
break;
case 's':
what = STORE;
break;
case 't':
flags |= O_TRUNC;
break;
case 'v':
verbose = 1;
break;
case 'x':
flags |= O_EXCL;
break;
case '!':
giveusage = 1;
break;
case '?':
if (argn < 3)
comarg[argn++] = optarg;
else {
fprintf(stderr, "Too many arguments.\n");
giveusage = 1;
}
break;
}
}
if (giveusage || what == YOW || argn < 1) {
fprintf(stderr, "Usage: %s database [-m r|w|rw] [-crtx] -a|-d|-f|-F|-s [key [content]]\n", argv[0]);
exit(-1);
}
if ((db = dbm_open(comarg[0], flags, 0777)) == NULL) {
fprintf(stderr, "Error opening database \"%s\"\n", comarg[0]);
exit(-1);
}
if (argn > 1)
key = read_datum(comarg[1]);
if (argn > 2)
content = read_datum(comarg[2]);
switch (what) {
case SCAN:
key = dbm_firstkey(db);
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching first key\n");
goto db_exit;
}
while (key.dptr != NULL) {
content = dbm_fetch(db, key);
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching ");
print_datum(key);
printf("\n");
goto db_exit;
}
print_datum(key);
printf(": ");
print_datum(content);
printf("\n");
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching next key\n");
goto db_exit;
}
key = dbm_nextkey(db);
}
break;
case REGEXP:
if (argn < 2) {
fprintf(stderr, "Missing regular expression.\n");
goto db_exit;
}
if (re_comp(comarg[1])) {
fprintf(stderr, "Invalid regular expression\n");
goto db_exit;
}
key = dbm_firstkey(db);
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching first key\n");
goto db_exit;
}
while (key.dptr != NULL) {
if (re_exec(key2s(key))) {
content = dbm_fetch(db, key);
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching ");
print_datum(key);
printf("\n");
goto db_exit;
}
print_datum(key);
printf(": ");
print_datum(content);
printf("\n");
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching next key\n");
goto db_exit;
}
}
key = dbm_nextkey(db);
}
break;
case FETCH:
if (argn < 2) {
fprintf(stderr, "Missing fetch key.\n");
goto db_exit;
}
content = dbm_fetch(db, key);
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching ");
print_datum(key);
printf("\n");
goto db_exit;
}
if (content.dptr == NULL) {
fprintf(stderr, "Cannot find ");
print_datum(key);
printf("\n");
goto db_exit;
}
print_datum(key);
printf(": ");
print_datum(content);
printf("\n");
break;
case DELETE:
if (argn < 2) {
fprintf(stderr, "Missing delete key.\n");
goto db_exit;
}
if (dbm_delete(db, key) || dbm_error(db)) {
fprintf(stderr, "Error when deleting ");
print_datum(key);
printf("\n");
goto db_exit;
}
if (verbose) {
print_datum(key);
printf(": DELETED\n");
}
break;
case STORE:
if (argn < 3) {
fprintf(stderr, "Missing key and/or content.\n");
goto db_exit;
}
if (dbm_store(db, key, content, st_flag) || dbm_error(db)) {
fprintf(stderr, "Error when storing ");
print_datum(key);
printf("\n");
goto db_exit;
}
if (verbose) {
print_datum(key);
printf(": ");
print_datum(content);
printf(" STORED\n");
}
break;
}
db_exit:
dbm_clearerr(db);
dbm_close(db);
if (dbm_error(db)) {
fprintf(stderr, "Error closing database \"%s\"\n", comarg[0]);
exit(-1);
}
}
static kadm5_ret_t kadm5_get_either(int princ,
void *server_handle,
char *exp,
char ***princs,
int *count)
{
struct iter_data data;
#ifdef BSD_REGEXPS
char *msg;
#endif
char *regexp;
int i, ret;
kadm5_server_handle_t handle = server_handle;
*count = 0;
if (exp == NULL)
exp = "*";
CHECK_HANDLE(server_handle);
if ((ret = glob_to_regexp(exp, princ ? handle->params.realm : NULL,
®exp)) != KADM5_OK)
return ret;
if (
#ifdef SOLARIS_REGEXPS
((data.expbuf = compile(regexp, NULL, NULL)) == NULL)
#endif
#ifdef POSIX_REGEXPS
((regcomp(&data.preg, regexp, REG_NOSUB)) != 0)
#endif
#ifdef BSD_REGEXPS
((msg = (char *) re_comp(regexp)) != NULL)
#endif
)
{
/* XXX syslog msg or regerr(regerrno) */
free(regexp);
return EINVAL;
}
data.n_names = 0;
data.sz_names = 10;
data.malloc_failed = 0;
data.names = malloc(sizeof(char *) * data.sz_names);
if (data.names == NULL) {
free(regexp);
return ENOMEM;
}
if (princ) {
data.context = handle->context;
ret = kdb_iter_entry(handle, exp, get_princs_iter, (void *) &data);
} else {
ret = krb5_db_iter_policy(handle->context, exp, get_pols_iter, (void *)&data);
}
free(regexp);
#ifdef POSIX_REGEXPS
regfree(&data.preg);
#endif
if ( !ret && data.malloc_failed)
ret = ENOMEM;
if ( ret ) {
for (i = 0; i < data.n_names; i++)
free(data.names[i]);
free(data.names);
return ret;
}
*princs = data.names;
*count = data.n_names;
return KADM5_OK;
}
static int
Netlist (int argc, char **argv, Coord x, Coord y)
{
NFunc func;
int i, j;
LibraryMenuType *net;
LibraryEntryType *pin;
int net_found = 0;
int pin_found = 0;
#if defined(USE_RE)
int use_re = 0;
#endif
#if defined(HAVE_REGCOMP)
regex_t elt_pattern;
regmatch_t match;
#endif
#if defined(HAVE_RE_COMP)
char *elt_pattern;
#endif
if (!PCB)
return 1;
if (argc == 0)
{
Message (netlist_syntax);
return 1;
}
if (strcasecmp (argv[0], "find") == 0)
func = netlist_find;
else if (strcasecmp (argv[0], "select") == 0)
func = netlist_select;
else if (strcasecmp (argv[0], "rats") == 0)
func = netlist_rats;
else if (strcasecmp (argv[0], "norats") == 0)
func = netlist_norats;
else if (strcasecmp (argv[0], "clear") == 0)
{
func = netlist_clear;
if (argc == 1)
{
netlist_clear (NULL, NULL);
return 0;
}
}
else if (strcasecmp (argv[0], "style") == 0)
func = (NFunc)netlist_style;
else if (strcasecmp (argv[0], "add") == 0)
{
/* Add is different, because the net/pin won't already exist. */
return netlist_add (ARG(1), ARG(2));
}
else if (strcasecmp (argv[0], "sort") == 0)
{
sort_netlist ();
return 0;
}
else if (strcasecmp (argv[0], "freeze") == 0)
{
netlist_frozen ++;
return 0;
}
else if (strcasecmp (argv[0], "thaw") == 0)
{
if (netlist_frozen > 0)
{
netlist_frozen --;
if (netlist_needs_update)
NetlistChanged (0);
}
return 0;
}
else if (strcasecmp (argv[0], "forcethaw") == 0)
{
netlist_frozen = 0;
if (netlist_needs_update)
NetlistChanged (0);
return 0;
}
else
{
Message (netlist_syntax);
return 1;
}
#if defined(USE_RE)
if (argc > 1)
{
int result;
use_re = 1;
for (i = 0; i < PCB->NetlistLib.MenuN; i++)
{
net = PCB->NetlistLib.Menu + i;
if (strcasecmp (argv[1], net->Name + 2) == 0)
use_re = 0;
}
if (use_re)
{
#if defined(HAVE_REGCOMP)
result =
regcomp (&elt_pattern, argv[1],
REG_EXTENDED | REG_ICASE | REG_NOSUB);
if (result)
{
char errorstring[128];
regerror (result, &elt_pattern, errorstring, 128);
Message (_("regexp error: %s\n"), errorstring);
regfree (&elt_pattern);
return (1);
}
#endif
#if defined(HAVE_RE_COMP)
if ((elt_pattern = re_comp (argv[1])) != NULL)
{
Message (_("re_comp error: %s\n"), elt_pattern);
return (false);
}
#endif
}
}
#endif
for (i = PCB->NetlistLib.MenuN-1; i >= 0; i--)
{
net = PCB->NetlistLib.Menu + i;
if (argc > 1)
{
#if defined(USE_RE)
if (use_re)
{
#if defined(HAVE_REGCOMP)
if (regexec (&elt_pattern, net->Name + 2, 1, &match, 0) != 0)
continue;
#endif
#if defined(HAVE_RE_COMP)
if (re_exec (net->Name + 2) != 1)
continue;
#endif
}
else
#endif
if (strcasecmp (net->Name + 2, argv[1]))
continue;
}
net_found = 1;
pin = 0;
if (func == (void *)netlist_style)
{
netlist_style (net, ARG(2));
}
else if (argc > 2)
{
int l = strlen (argv[2]);
for (j = net->EntryN-1; j >= 0 ; j--)
if (strcasecmp (net->Entry[j].ListEntry, argv[2]) == 0
|| (strncasecmp (net->Entry[j].ListEntry, argv[2], l) == 0
&& net->Entry[j].ListEntry[l] == '-'))
{
pin = net->Entry + j;
pin_found = 1;
func (net, pin);
}
}
else
func (net, 0);
}
if (argc > 2 && !pin_found)
{
gui->log ("Net %s has no pin %s\n", argv[1], argv[2]);
return 1;
}
else if (!net_found)
{
gui->log ("No net named %s\n", argv[1]);
}
#ifdef HAVE_REGCOMP
if (use_re)
regfree (&elt_pattern);
#endif
return 0;
}
static void split(const char *fn)
{
FILE *fp, *op = NULL;
long long bytes = bytecount, lines = linecount, n, m;
char b[4096];
int c;
if (fn[0] == '-' && fn[1] == '\0')
fp = stdin;
else if ((fp = fopen(fn, "r")) == NULL) {
fprintf(stderr, "cannot open input");
exit(1);
}
if (linecount > 0) {
if (pattern == NULL) {
while ((c = getc(fp)) != EOF) {
if (lines >= linecount) {
lines = 0;
if (op)
fclose(op);
op = nextfile();
}
putc(c, op);
if (c == '\n')
lines++;
}
} else {
/* process line by line and only count lines
matching the pattern */
if (re_comp(pattern) != NULL)
usage();
while (fgets(b, 4096, fp) != NULL) {
/* does the line match? */
if (re_exec(b))
lines++;
if (lines >= linecount) {
lines = 0;
if (op)
fclose(op);
op = nextfile();
}
fputs(b, op);
}
}
} else {
do {
if ((n = bytecount - bytes) > sizeof b)
n = sizeof b;
else if (n == 0 && (n = bytecount) > sizeof b)
n = sizeof b;
m = fread(b, 1, n, fp);
if (bytes >= bytecount) {
bytes = 0;
if (op)
fclose(op);
op = nextfile();
}
if (m) {
fwrite(b, 1, m, op);
bytes += m;
}
}
while (m);
}
}
static int
ReportNetLengthByName (char *tofind, int x, int y)
{
int result;
char *netname = 0;
Coord length = 0;
int found = 0;
int i;
LibraryMenuType *net;
ConnectionType conn;
int net_found = 0;
#if defined(USE_RE)
int use_re = 0;
#endif
#if defined(HAVE_REGCOMP)
regex_t elt_pattern;
regmatch_t match;
#endif
#if defined(HAVE_RE_COMP)
char *elt_pattern;
#endif
if (!PCB)
return 1;
if (!tofind)
return 1;
#if defined(USE_RE)
use_re = 1;
for (i = 0; i < PCB->NetlistLib.MenuN; i++)
{
net = PCB->NetlistLib.Menu + i;
if (strcasecmp (tofind, net->Name + 2) == 0)
use_re = 0;
}
if (use_re)
{
#if defined(HAVE_REGCOMP)
result =
regcomp (&elt_pattern, tofind,
REG_EXTENDED | REG_ICASE | REG_NOSUB);
if (result)
{
char errorstring[128];
regerror (result, &elt_pattern, errorstring, 128);
Message (_("regexp error: %s\n"), errorstring);
regfree (&elt_pattern);
return (1);
}
#endif
#if defined(HAVE_RE_COMP)
if ((elt_pattern = re_comp (tofind)) != NULL)
{
Message (_("re_comp error: %s\n"), elt_pattern);
return (1);
}
#endif
}
#endif
for (i = 0; i < PCB->NetlistLib.MenuN; i++)
{
net = PCB->NetlistLib.Menu + i;
#if defined(USE_RE)
if (use_re)
{
#if defined(HAVE_REGCOMP)
if (regexec (&elt_pattern, net->Name + 2, 1, &match, 0) != 0)
continue;
#endif
#if defined(HAVE_RE_COMP)
if (re_exec (net->Name + 2) != 1)
continue;
#endif
}
else
#endif
if (strcasecmp (net->Name + 2, tofind))
continue;
if (SeekPad (net->Entry, &conn, false))
{
switch (conn.type)
{
case PIN_TYPE:
x = ((PinType *) (conn.ptr2))->X;
y = ((PinType *) (conn.ptr2))->Y;
net_found=1;
break;
case PAD_TYPE:
x = ((PadType *) (conn.ptr2))->Point1.X;
y = ((PadType *) (conn.ptr2))->Point1.Y;
net_found=1;
break;
}
if (net_found)
break;
}
}
if (!net_found)
{
gui->log (_("No net named %s\n"), tofind);
return 1;
}
#ifdef HAVE_REGCOMP
if (use_re)
regfree (&elt_pattern);
#endif
/* Reset all connection flags and save an undo-state to get back
* to the state the board was in when we started.
*
* After this, we don't add any changes to the undo system, but
* ensure we get back to a point where we can Undo() our changes
* by resetting the connections with ClearFlagOnAllObjects() before
* calling Undo() when we are finished.
*/
ClearFlagOnAllObjects (true, FOUNDFLAG);
IncrementUndoSerialNumber ();
length = XYtoNetLength (x, y, &found);
netname = net->Name + 2;
ClearFlagOnAllObjects (false, FOUNDFLAG);
Undo (true);
if (!found)
{
if (net_found)
gui->log (_("Net found, but no lines or arcs were flagged.\n"));
else
gui->log (_("Net not found.\n"));
return 1;
}
{
char buf[50];
pcb_snprintf(buf, 50, _("%$m*"), Settings.grid_unit->suffix, length);
if (netname)
gui->log (_("Net \"%s\" length: %s\n"), netname, buf);
else
gui->log (_("Net length: %s\n"), buf);
}
return 0;
}
void
kdb5_update_princ_encryption(int argc, char *argv[])
{
struct update_enc_mkvno data = { 0 };
char *name_pattern = NULL;
int force = 0;
int optchar;
krb5_error_code retval;
krb5_actkvno_node *actkvno_list = 0;
krb5_db_entry *master_entry;
char *mkey_fullname = 0;
#ifdef BSD_REGEXPS
char *msg;
#endif
char *regexp = NULL;
krb5_keyblock *act_mkey;
krb5_keylist_node *master_keylist = krb5_db_mkey_list_alias(util_context);
while ((optchar = getopt(argc, argv, "fnv")) != -1) {
switch (optchar) {
case 'f':
force = 1;
break;
case 'n':
data.dry_run = 1;
break;
case 'v':
data.verbose = 1;
break;
case '?':
case ':':
default:
usage();
}
}
if (argv[optind] != NULL) {
name_pattern = argv[optind];
if (argv[optind+1] != NULL)
usage();
}
retval = krb5_unparse_name(util_context, master_princ, &mkey_fullname);
if (retval) {
com_err(progname, retval, _("while formatting master principal name"));
exit_status++;
goto cleanup;
}
if (master_keylist == NULL) {
com_err(progname, retval, _("master keylist not initialized"));
exit_status++;
goto cleanup;
}
/* The glob_to_regexp code only cares if the "realm" parameter is
NULL or not; the string data is irrelevant. */
if (name_pattern == NULL)
name_pattern = "*";
if (glob_to_regexp(name_pattern, "hi", ®exp) != 0) {
com_err(progname, ENOMEM,
_("converting glob pattern '%s' to regular expression"),
name_pattern);
exit_status++;
goto cleanup;
}
if (
#ifdef SOLARIS_REGEXPS
((data.expbuf = compile(regexp, NULL, NULL)) == NULL)
#endif
#ifdef POSIX_REGEXPS
((regcomp(&data.preg, regexp, REG_NOSUB)) != 0)
#endif
#ifdef BSD_REGEXPS
((msg = (char *) re_comp(regexp)) != NULL)
#endif
) {
/* XXX syslog msg or regerr(regerrno) */
com_err(progname, 0, _("error compiling converted regexp '%s'"),
regexp);
exit_status++;
goto cleanup;
}
retval = krb5_db_get_principal(util_context, master_princ, 0,
&master_entry);
if (retval != 0) {
com_err(progname, retval, _("while getting master key principal %s"),
mkey_fullname);
exit_status++;
goto cleanup;
}
retval = krb5_dbe_lookup_actkvno(util_context, master_entry, &actkvno_list);
if (retval != 0) {
com_err(progname, retval, _("while looking up active kvno list"));
exit_status++;
goto cleanup;
}
retval = krb5_dbe_find_act_mkey(util_context, actkvno_list, &new_mkvno,
&act_mkey);
if (retval) {
com_err(progname, retval, _("while looking up active master key"));
exit_status++;
goto cleanup;
}
new_master_keyblock = *act_mkey;
if (!force &&
!data.dry_run &&
!are_you_sure(_("Re-encrypt all keys not using master key vno %u?"),
new_mkvno)) {
printf(_("OK, doing nothing.\n"));
exit_status++;
goto cleanup;
}
if (data.verbose) {
if (data.dry_run) {
printf(_("Principals whose keys WOULD BE re-encrypted to master "
"key vno %u:\n"), new_mkvno);
} else {
printf(_("Principals whose keys are being re-encrypted to master "
"key vno %u if necessary:\n"), new_mkvno);
}
}
if (!data.dry_run) {
/* Grab a write lock so we don't have to upgrade to a write lock and
* reopen the DB while iterating. */
retval = krb5_db_lock(util_context, KRB5_DB_LOCKMODE_EXCLUSIVE);
if (retval != 0 && retval != KRB5_PLUGIN_OP_NOTSUPP) {
com_err(progname, retval, _("trying to lock database"));
exit_status++;
}
}
retval = krb5_db_iterate(util_context, name_pattern,
update_princ_encryption_1, &data);
/* If exit_status is set, then update_princ_encryption_1 already
printed a message. */
if (retval != 0 && exit_status == 0) {
com_err(progname, retval, _("trying to process principal database"));
exit_status++;
}
if (!data.dry_run)
(void)krb5_db_unlock(util_context);
(void) krb5_db_fini(util_context);
if (data.dry_run) {
printf(_("%u principals processed: %u would be updated, %u already "
"current\n"),
data.re_match_count, data.updated, data.already_current);
} else {
printf(_("%u principals processed: %u updated, %u already current\n"),
data.re_match_count, data.updated, data.already_current);
}
cleanup:
free(regexp);
memset(&new_master_keyblock, 0, sizeof(new_master_keyblock));
krb5_free_unparsed_name(util_context, mkey_fullname);
krb5_dbe_free_actkvno_list(util_context, actkvno_list);
}
/* ARGSUSED */
static int
ls_fileproc (void *callerdat, struct file_info *finfo)
{
Vers_TS *vers;
char *regex_err;
Node *p, *n;
bool isdead;
const char *filename;
if (regexp_match)
{
#ifdef FILENAMES_CASE_INSENSITIVE
re_set_syntax (REG_ICASE|RE_SYNTAX_EGREP);
#else
re_set_syntax (RE_SYNTAX_EGREP);
#endif
if ((regex_err = re_comp (regexp_match)) != NULL)
{
error (1, 0, "bad regular expression passed to 'ls': %s",
regex_err);
}
if (re_exec (finfo->file) == 0)
return 0; /* no match */
}
vers = Version_TS (finfo, NULL, show_tag, show_date, 1, 0);
/* Skip dead revisions unless specifically requested to do otherwise.
* We also bother to check for long_format so we can print the state.
*/
if (vers->vn_rcs && (!show_dead_revs || long_format))
isdead = RCS_isdead (finfo->rcs, vers->vn_rcs);
else
isdead = false;
if (!vers->vn_rcs || (!show_dead_revs && isdead))
{
freevers_ts (&vers);
return 0;
}
p = findnode (callerdat, finfo->update_dir);
if (!p)
{
/* This only occurs when a complete path to a file is specified on the
* command line. Put the file in the root list.
*/
filename = finfo->fullname;
/* Add update_dir node. */
p = findnode (callerdat, ".");
if (!p)
{
p = getnode ();
p->key = xstrdup (".");
p->data = getlist ();
p->delproc = ls_delproc;
addnode (callerdat, p);
}
}
else
filename = finfo->file;
n = getnode();
if (entries_format)
{
char *outdate = entries_time (RCS_getrevtime (finfo->rcs, vers->vn_rcs,
0, 0));
n->data = Xasprintf ("/%s/%s/%s/%s/%s%s\n",
filename, vers->vn_rcs,
outdate, vers->options,
show_tag ? "T" : "", show_tag ? show_tag : "");
free (outdate);
}
else if (long_format)
{
struct long_format_data *out =
xmalloc (sizeof (struct long_format_data));
out->header = Xasprintf ("%-5.5s",
vers->options[0] != '\0' ? vers->options
: "----");
/* FIXME: Do we want to mimc the real `ls' command's date format? */
out->time = gmformat_time_t (RCS_getrevtime (finfo->rcs, vers->vn_rcs,
0, 0));
out->footer = Xasprintf (" %-9.9s%s %s%s", vers->vn_rcs,
strlen (vers->vn_rcs) > 9 ? "+" : " ",
show_dead_revs ? (isdead ? "dead " : " ")
: "",
filename);
n->data = out;
n->delproc = long_format_data_delproc;
}
else
n->data = Xasprintf ("%s\n", filename);
addnode (p->data, n);
freevers_ts (&vers);
return 0;
}
static bool
rematch (const char *re, const char *s)
{
/*
* If this system has regular expression capability, then
* add support for regular expressions in the skip lists.
*/
#if defined(HAVE_REGCOMP)
int result;
regmatch_t match;
regex_t compiled;
/* compile the regular expression */
result = regcomp (&compiled, re, REG_EXTENDED | REG_ICASE | REG_NOSUB);
if (result)
{
char errorstring[128];
regerror (result, &compiled, errorstring, sizeof (errorstring));
Message ("regexp error: %s\n", errorstring);
regfree (&compiled);
return (false);
}
result = regexec (&compiled, s, 1, &match, 0);
regfree (&compiled);
if (result == 0)
return (true);
else
return (false);
#elif defined(HAVE_RE_COMP)
int m;
char *rslt;
/* compile the regular expression */
if ((rslt = re_comp (re)) != NULL)
{
Message ("re_comp error: %s\n", rslt);
return (false);
}
m = re_exec (s);
switch m
{
case 1:
return (true);
break;
case 0:
return (false);
break;
default:
Message ("re_exec error\n");
break;
}
#else
return (false);
#endif
}
void runSuccess1() {
re_comp(NULL);
}
CONDITION
UTL_RegexMatch(char *regex, char *stm)
{
#if (HAVE_REGEX_H && HAVE_REGCOMP)
int
ret,
regexReturn;
char
*new_rstring;
regex_t preg;
char errorBuff[256];
regmatch_t pmatch;
new_rstring = UTL_ConvertRegex(regex);
regexReturn = regcomp(&preg, new_rstring, 0);
if (regexReturn != 0) {
regerror(regexReturn, &preg, errorBuff, sizeof(errorBuff));
fprintf(stderr, "%d\n", regexReturn);
fprintf(stderr, "%s\n", errorBuff);
free(new_rstring);
return (UTL_NOMATCH);
} else {
ret = regexec(&preg, stm, 1, &pmatch, 0);
switch (ret) {
case 0:
free(new_rstring);
return (UTL_MATCH);
break;
default:
free(new_rstring);
return (UTL_NOMATCH);
break;
}
}
#elif HAVE_RE_COMP
int
ret;
char
*new_rstring;
new_rstring = UTL_ConvertRegex(regex);
if (re_comp(new_rstring) != (char *) 0) {
free(new_rstring);
return (UTL_NOMATCH);
} else {
ret = re_exec(stm);
switch (ret) {
case 0:
case -1:
free(new_rstring);
return (UTL_NOMATCH);
break;
case 1:
free(new_rstring);
return (UTL_MATCH);
break;
}
}
#else
#error No suitable regular expression library found, sorry.
#endif
}
