static void nss_test_groups(void)
{
struct group *grp;
nss_setgrent();
/* loop over all groups */
while ((grp = nss_getgrent())) {
printf("Testing group %s\n", grp->gr_name);
printf("getgrent: "); print_group(grp);
grp = nss_getgrnam(grp->gr_name);
if (!grp) {
total_errors++;
printf("ERROR: can't getgrnam\n");
continue;
}
printf("getgrnam: "); print_group(grp);
grp = nss_getgrgid(grp->gr_gid);
if (!grp) {
total_errors++;
printf("ERROR: can't getgrgid\n");
continue;
}
printf("getgrgid: "); print_group(grp);
printf("\n");
}
nss_endgrent();
}
static void
print_group_list (char *username)
{
print_group (rgid);
if (egid != rgid)
{
putchar (' ');
print_group (egid);
}
#if HAVE_GETGROUPS
{
int n_groups;
GETGROUPS_T *groups;
register int i;
if (xgetgroups (username, &n_groups, &groups))
{
++problems;
return;
}
for (i = 0; i < n_groups; i++)
if (groups[i] != rgid && groups[i] != egid)
{
putchar (' ');
print_group (groups[i]);
}
free (groups);
}
#endif
}
rtems_task Init(
rtems_task_argument ignored
)
{
struct passwd *pw;
struct group *gr;
puts( "*** PASSWORD/GROUP TEST ***" );
/* getpwnam */
puts( "Init - getpwnam(\"root\") -- OK" );
pw = getpwnam("root");
rtems_test_assert( pw );
print_passwd( pw );
puts( "Init - getpwnam(\"rtems\") -- OK" );
pw = getpwnam("rtems");
rtems_test_assert( pw );
print_passwd( pw );
/* getgrnam */
puts( "Init - getgrnam(\"root\") -- OK" );
gr = getgrnam("root");
rtems_test_assert( gr );
print_group( gr );
puts( "Init - getgrnam(\"rtems\") -- OK" );
gr = getgrnam("rtems");
rtems_test_assert( gr );
print_group( gr );
puts( "*** END OF PASSWORD/GROUP TEST ***" );
rtems_test_exit( 0 );
}
/* Print all of the distinct groups the user is in. */
extern bool
print_group_list (const char *username,
uid_t ruid, gid_t rgid, gid_t egid,
bool use_names)
{
bool ok = true;
struct passwd *pwd;
pwd = getpwuid (ruid);
if (pwd == NULL)
ok = false;
if (!print_group (rgid, use_names))
ok = false;
if (egid != rgid)
{
putchar (' ');
if (!print_group (egid, use_names))
ok = false;
}
#if HAVE_GETGROUPS
{
GETGROUPS_T *groups;
int i;
int n_groups = mgetgroups (username, (pwd ? pwd->pw_gid : (gid_t) -1),
&groups);
if (n_groups < 0)
{
if (username)
{
error (0, errno, _("failed to get groups for user %s"),
quote (username));
}
else
{
error (0, errno, _("failed to get groups for the current process"));
}
return false;
}
for (i = 0; i < n_groups; i++)
if (groups[i] != rgid && groups[i] != egid)
{
putchar (' ');
if (!print_group (groups[i], use_names))
ok = false;
}
free (groups);
}
#endif /* HAVE_GETGROUPS */
return ok;
}
/* Print all of the distinct groups the user is in. */
extern bool
print_group_list (const char *username,
uid_t ruid, gid_t rgid, gid_t egid,
bool use_names, char delim)
{
bool ok = true;
struct passwd *pwd = NULL;
if (username)
{
pwd = getpwuid (ruid);
if (pwd == NULL)
ok = false;
}
if (!print_group (rgid, use_names))
ok = false;
if (egid != rgid)
{
putchar (delim);
if (!print_group (egid, use_names))
ok = false;
}
{
gid_t *groups;
int n_groups = xgetgroups (username, (pwd ? pwd->pw_gid : egid), &groups);
if (n_groups < 0)
{
if (username)
{
error (0, errno, _("failed to get groups for user %s"),
quote (username));
}
else
{
error (0, errno, _("failed to get groups for the current process"));
}
return false;
}
for (int i = 0; i < n_groups; i++)
if (groups[i] != rgid && groups[i] != egid)
{
putchar (delim);
if (!print_group (groups[i], use_names))
ok = false;
}
free (groups);
}
return ok;
}
void group_warning(void)
{
boolean w= false;
int i= in_open;
base_ptr= input_ptr;
input_stack[base_ptr]= cur_input;
while((grp_stack[i]==cur_boundary)&&(i> 0)){
if(tracing_nesting_par> 0){
while((input_stack[base_ptr].state_field==token_list)||
(input_stack[base_ptr].index_field> i))
decr(base_ptr);
if(input_stack[base_ptr].name_field> 17)
w= true;
}
grp_stack[i]= save_value(save_ptr);
decr(i);
}
if(w){
tprint_nl("Warning: end of ");
print_group(true);
tprint(" of a different file");
print_ln();
if(tracing_nesting_par> 1)
show_context();
if(history==spotless)
history= warning_issued;
}
}
//********************************************************
void WordsEdit::update_group(int curgroup)
{
print_group(curgroup);
listgroup->changeItem(tmp,curgroup);
}
//-------------------------------------------------------------------------------------------------
void MessageBase::print(ostream& os, int depth) const
{
const string dspacer((depth + 1) * 3, ' ');
const BaseMsgEntry *tbme(_ctx._bme.find_ptr(_msgType.c_str()));
if (tbme)
os << tbme->_name << " (\"" << _msgType << "\")" << endl;
for (Positions::const_iterator itr(_pos.begin()); itr != _pos.end(); ++itr)
{
const BaseEntry *tbe(_ctx.find_be(itr->second->_fnum));
if (!tbe)
throw InvalidField(itr->second->_fnum);
os << dspacer << tbe->_name;
const unsigned short comp(_fp.getComp(itr->second->_fnum));
if (comp)
os << " [" << _ctx._cn[comp] << ']';
os << " (" << itr->second->_fnum << "): ";
int idx;
if (itr->second->_rlm && (idx = (itr->second->get_rlm_idx())) >= 0)
os << itr->second->_rlm->_descriptions[idx] << " (" << *itr->second << ')' << endl;
else
os << *itr->second << endl;
if (_fp.is_group(itr->second->_fnum))
print_group(itr->second->_fnum, os, depth);
}
}
static void
print_changelog (ptr<sfsauth2_query_res> aqr, str sfshost)
{
if (!aqr)
exit (1);
if (aqr->type == SFSAUTH_ERROR)
fatal << "Error: " << *aqr->errmsg << "\n";
if (aqr->type == SFSAUTH_GROUP) {
print_group (false, aqr, sfshost);
return;
}
strbuf refresh, timeout;
refresh << aqr->logentry->refresh << " seconds ("
<< seconds2str (aqr->logentry->refresh) << ")\n";
timeout << aqr->logentry->timeout << " seconds ("
<< seconds2str (aqr->logentry->timeout) << ")\n";
strbuf s;
unsigned int i;
s << " Audit: " << aqr->logentry->audit << "\n";
s << " Version: " << aqr->logentry->vers << "\n";
s << " Refresh: " << refresh;
s << " Timeout: " << timeout;
for (i = 0; i < aqr->logentry->members.size (); i++)
s << " " << aqr->logentry->members[i] << "\n";
warnx << s;
exit (0);
}
void *snag_vertex(FILE *fpin, char *s, char *value, int *group, int *type)
{
VertexEntity *item;
item = (VertexEntity *)malloc(sizeof(VertexEntity));
if (!item) {
printf("malloc failed\n");
return NULL;
}
/* common defaults */
common_defaults((void *)item);
/* entity defaults */
item->start_width = default_polyline_start_width;
item->end_width = default_polyline_end_width;
item->bulge = 0.0;
item->vert_flags = 0x0;
item->tangent = 0.0;
item->mesh_indicies[0] = item->mesh_indicies[1] =
item->mesh_indicies[2] = item->mesh_indicies[3] = 0;
/*
* Assume that we can read to the next entity group
*/
while (TRUE) {
get_next_group(fpin, REQUIRED, s, value, group, type);
if (is_common(*group)) {
/* common stuff */
handle_common((void *)item, *group, value);
continue;
}
switch (*group) {
/* location */
case G_X_COOR1: item->loc[0] = atof(value); break;
case G_Y_COOR1: item->loc[1] = atof(value); break;
case G_Z_COOR1: item->loc[2] = atof(value); break;
/* start_wdith */
case G_FLOAT1: item->start_width = atof(value); break;
/* end width */
case G_FLOAT2: item->end_width = atof(value); break;
/* bulge */
case G_FLOAT3: item->bulge = atof(value); break;
/* vert_flag */
case G_INT1: item->vert_flags = strtol(value,NULL,0); break;
/* curve fit tangent */
case G_ANGLE1: item->tangent = atof(value); break;
/* vertex indicies (for mesh) -- ignore edge invisble flag -- i.e. -1 */
case G_INT2: item->mesh_indicies[0] = abs(strtol(value,NULL,0)); break;
case G_INT3: item->mesh_indicies[1] = abs(strtol(value,NULL,0)); break;
case G_INT4: item->mesh_indicies[2] = abs(strtol(value,NULL,0)); break;
case G_INT5: item->mesh_indicies[3] = abs(strtol(value,NULL,0)); break;
/* next group */
case G_FILE_SEP:
rewind_file();
return (void *)item;
default:
print_group("Unknown group in VERTEX", *group, value, IGNORE);
}
}
}
static void print_company(const company& com)
{
printf("\r\ncompany ---> name: %s, addr: %s\r\n",
com.name.c_str(), com.addr.c_str());
for (auto cit : com.groups)
print_group(cit);
}
void *snag_shape(FILE *fpin, char *s, char *value, int *group, int *type)
{
Shape *item;
item = (Shape *)malloc(sizeof(Shape));
if (!item) {
printf("malloc failed\n");
return NULL;
}
/* common defaults */
common_defaults((void *)item);
/* entity defaults */
item->rot = 0.0;
item->x_scale = 1.0;
item->oblique = 0.0;
while (TRUE) {
/*
* Assume that we can read to the next entity group
*/
get_next_group(fpin, REQUIRED, s, value, group, type);
if (is_common(*group)) {
/* common stuff */
handle_common((void *)item, *group, value);
continue;
}
switch (*group) {
/* val */
case G_NAME:
strncpy(item->name,value,10);
break;
/* size */
case G_FLOAT1: item->size = atof(value); break;
/* x_scale */
case G_FLOAT2: item->x_scale = atof(value); break;
/* rot */
case G_ANGLE1: item->rot = atof(value); break;
/* oblique */
case G_ANGLE2: item->oblique = atof(value); break;
/* point */
case G_X_COOR1: item->pt[0] = atof(value); break;
case G_Y_COOR1: item->pt[1] = atof(value); break;
case G_Z_COOR1: item->pt[2] = atof(value); break;
/* next group */
case G_FILE_SEP:
rewind_file();
return (void *)item;
default:
print_group("Unknown group in SHAPE", *group, value, IGNORE);
}
}
}
int svcBrowse(uuid_t *groupToExtract)
{
int status = -1, i;
uint16_t count = 0;
slist_t *searchList = NULL;
slist_t *attrIdList = NULL;
slist_t *svcRecList = NULL;
sdpsvc_t *svcRec;
s_list_append(&searchList, groupToExtract);
s_list_append_uint(&attrIdList, 0x0000ffff);
status = sdp_search_attr_req(srvHandle, searchList,
RangeOfAttributes, attrIdList, 0xFFFF, &svcRecList, &count);
s_list_free(&attrIdList);
s_list_free(&searchList);
//printf("Status : %d Count : %d, list: %d\n", status, count, s_list_length(svcRecList));
if (status || count == 0)
return status;
for (i = 0; i < s_list_length(svcRecList); i++) {
printf("==============================\n");
svcRec = (sdpsvc_t *)s_list_nth_data(svcRecList, i);
print_info_attr(svcRec);
printf("------------------------------\n");
printf("SvcRecHdl: 0x%x\n", svcRec->serviceRecordHandle);
if (!verboseflag) {
print_svc_class(svcRec);
print_access_proto(svcRec);
print_profile_desc(svcRec);
print_group(svcRec);
} else {
// print detailed info
}
if (sdp_is_group(svcRec)) {
uuid_t *groupId;
// printf("SvcRec : 0x%x is a group\n", svcRecHandle);
printf("This is a group.\n");
groupId = sdp_get_group_attr(svcRec);
printf(" 0x%s\n", sdp_uuid2str(groupId));
if (sdp_uuidcmp(groupId, groupToExtract) != 0) {
printf("Extracting it\n");
svcBrowse(groupId);
}
}
}
sdp_free_svclist(&svcRecList);
return status;
}
int main(int argc, char **argv) {
struct stat sb;
if(argc < 2) {
fprintf(stderr, "Error: %s <PATH>\n", argv[0]);
exit(-2);
}
if(lstat(argv[1], &sb) == 0) {
if(sb.st_mode & S_IFLNK) {
char tgt[MAXPATHLEN];
if(readlink(argv[1], tgt, sizeof(tgt)) > 0) {
printf("link\ts\t%s\n", tgt);
}
}
}
time_t now = time(NULL);
if(stat(argv[1], &sb) == 0) {
printf("exists\tL\t1\n");
#if defined(STAT_TIME_T)
#define PTIME(TYPE) do { \
printf(#TYPE "time\tL\t%ld\n", sb.st_##TYPE##time); \
printf(#TYPE "age\tL\t%ld\n", now - sb.st_##TYPE##time); \
} while(0)
#elif defined(STAT_TIMESPEC)
#define PTIME(TYPE) do { \
printf(#TYPE "time\tL\t%ld\n", sb.st_##TYPE##timespec.tv_sec); \
printf(#TYPE "age\tL\t%ld\n", now - sb.st_##TYPE##timespec.tv_sec); \
} while(0)
#else
#define PTIME(TYPE) do { \
printf(#TYPE "time\tL\t%ld\n", sb.st_##TYPE##time.tv_sec); \
printf(#TYPE "age\tL\t%ld\n", now - sb.st_##TYPE##time.tv_sec); \
} while(0)
#endif
PTIME(m);
PTIME(a);
PTIME(c);
printf("hardlinks\tL\t%lu\n", (unsigned long)sb.st_nlink);
printf("size\tL\t%llu\n", (unsigned long long)sb.st_size);
printf("permissions\ts\t%04o\n", 0xfff & sb.st_mode);
printf("type\ts\t%c\n",
S_ISREG(sb.st_mode) ? 'f' :
S_ISDIR(sb.st_mode) ? 'd' :
S_ISLNK(sb.st_mode) ? 'l' :
S_ISBLK(sb.st_mode) ? 'b' :
S_ISCHR(sb.st_mode) ? 'c' :
S_ISFIFO(sb.st_mode) ? 'p' :
S_ISSOCK(sb.st_mode) ? 's' : '?');
print_user(sb.st_uid);
print_group(sb.st_gid);
} else {
printf("exists\tL\t1\n");
}
}
void *snag_3dface(FILE *fpin, char *s, char *value, int *group, int *type)
{
Face3d *item;
item = (Face3d *)malloc(sizeof(Face3d));
if (!item) {
printf("malloc failed\n");
return NULL;
}
/* common defaults */
common_defaults((void *)item);
/* entity defaults */
item->edge_vis_flag = 0;
/*
* Assume that we can read to the next entity group
*/
while (TRUE) {
get_next_group(fpin, REQUIRED, s, value, group, type);
if (is_common(*group)) {
/* common stuff */
handle_common((void *)item, *group, value);
continue;
}
switch (*group) {
/* edge visibility flag */
case G_INT1: item->edge_vis_flag = strtol(value,NULL,0); break;
/* pt1 */
case G_X_COOR1: item->pt1[0] = atof(value); break;
case G_Y_COOR1: item->pt1[1] = atof(value); break;
case G_Z_COOR1: item->pt1[2] = atof(value); break;
/* pt2 */
case G_X_COOR2: item->pt2[0] = atof(value); break;
case G_Y_COOR2: item->pt2[1] = atof(value); break;
case G_Z_COOR2: item->pt2[2] = atof(value); break;
/* pt3 */
case G_X_COOR3: item->pt3[0] = atof(value); break;
case G_Y_COOR3: item->pt3[1] = atof(value); break;
case G_Z_COOR3: item->pt3[2] = atof(value); break;
/* pt2 */
case G_X_COOR4: item->pt4[0] = atof(value); break;
case G_Y_COOR4: item->pt4[1] = atof(value); break;
case G_Z_COOR4: item->pt4[2] = atof(value); break;
/* next group */
case G_FILE_SEP:
rewind_file();
return (void *)item;
default:
print_group("Unknown group in FACE", *group, value, IGNORE);
}
}
}
void group_trace(boolean e)
{
begin_diagnostic();
print_char('{');
if(e)
tprint("leaving ");
else
tprint("entering ");
print_group(e);
print_char('}');
end_diagnostic(false);
}
void write_savefile(const char *name)
{
unsigned int ntraces;
struct ltt_trace **tab;
FILE *fp;
ntraces = count_traces();
if (ntraces == 0)
return;
tab = malloc(ntraces*sizeof(struct ltt_trace *));
assert(tab);
fp = fopen(name, "wb");
if (fp == NULL)
FATAL("cannot write savefile '%s': %s\n", name,
strerror(errno));
INFO("writing SAV file '%s'...\n", name);
print_group(TG_IRQ, "Interrupts", fp, tab);
print_group(TG_MM, "Memory Management", fp, tab);
print_group(TG_GLOBAL, "Global Info", fp, tab);
print_group(TG_USER, "User Info", fp, tab);
print_group(TG_PROCESS, "Processes", fp, tab);
print_group(TG_APM, "Ardupilot", fp, tab);
free(tab);
fclose(fp);
}
//********************************************************
void WordsEdit::new_file()
{
setCaption("WORDS.TOK Editor");
wordlist->clear();
listgroup->clear();
listwords->clear();
for(int i=0;i<3;i++){
print_group(i);
listgroup->insertItem(tmp);
}
filename="";
}
void *snag_block(FILE *fpin, char *s, char *value, int *group, int *type)
{
Block *item;
int i;
item = (Block *)malloc(sizeof(Block));
if (!item) {
printf("malloc failed\n");
return NULL;
}
/* common defaults */
common_defaults((void *)item);
/* entity defaults */
item->processed = FALSE;
init_list(&item->entities);
while (TRUE) {
/*
* Assume that we can read to the next entity group
*/
get_next_group(fpin, REQUIRED, s, value, group, type);
if (is_common(*group)) {
handle_common((void *)item, *group, value);
continue;
}
switch (*group) {
/* base point */
case G_X_COOR1: item->loc[0] = atof(value); break;
case G_Y_COOR1: item->loc[1] = atof(value); break;
case G_Z_COOR1: item->loc[2] = atof(value); break;
/* flags */
case G_INT1: item->flags = strtol(value,NULL,0); break;
/* name */
case G_NAME: strncpy(item->name,value,25); break;
/* external reference -- v. 11 and later */
case G_TEXT_STRING: strncpy(item->external_ref,value,50); break;
/* other text -- v. 11 and later */
case G_OTHER_TEXT1: strncpy(item->other_text,value,25); break;
/* next group */
case G_FILE_SEP:
rewind_file();
return (void *)item;
default:
print_group("Unknown group in BLOCK", *group, value, IGNORE);
}
}
}
//-------------------------------------------------------------------------------------------------
void MessageBase::print_field(const unsigned short fnum, ostream& os) const
{
Fields::const_iterator fitr(_fields.find(fnum));
if (fitr != _fields.end())
{
const BaseEntry *tbe(_ctx.find_be(fnum));
if (!tbe)
throw InvalidField(fnum);
os << tbe->_name << " (" << fnum << "): ";
int idx;
if (fitr->second->_rlm && (idx = (fitr->second->get_rlm_idx())) >= 0)
os << fitr->second->_rlm->_descriptions[idx] << " (" << *fitr->second << ')';
else
os << *fitr->second;
if (_fp.is_group(fnum))
print_group(fnum, os, 0);
}
}
void *snag_end_block(FILE *fpin, char *s, char *value, int *group, int *type)
{
while (TRUE) {
/* No groups except maybe the common defaults -- so just read them
in and safely ignore them */
get_next_group(fpin, REQUIRED, s, value, group, type);
if (is_common(*group)) {
continue;
}
switch (*group) {
case G_FILE_SEP:
rewind_file();
return NULL;
default:
print_group("Unknown group in ENDBLOCK", *group, value, IGNORE);
}
}
}
void *snag_arc(FILE *fpin, char *s, char *value, int *group, int *type)
{
Arc *item;
item = (Arc *)malloc(sizeof(Arc));
if (!item) {
printf("malloc failed\n");
return NULL;
}
/* common defaults */
common_defaults((void *)item);
/* entity defaults */
/* none */
/*
* Assume that we can read to the next entity group
*/
while (TRUE) {
get_next_group(fpin, REQUIRED, s, value, group, type);
if (is_common(*group)) {
/* common stuff */
handle_common((void *)item, *group, value);
continue;
}
switch (*group) {
/* center */
case G_X_COOR1: item->center[0] = atof(value); break;
case G_Y_COOR1: item->center[1] = atof(value); break;
case G_Z_COOR1: item->center[2] = atof(value); break;
/* radius */
case G_FLOAT1: item->radius = atof(value); break;
/* start and stop angles */
case G_ANGLE1: item->start_angle = atof(value); break;
case G_ANGLE2: item->end_angle = atof(value); break;
/* next group */
case G_FILE_SEP:
rewind_file();
return (void *)item;
default:
print_group("Unknown group in ARC", *group, value, IGNORE);
}
}
}
void file_warning(void)
{
halfword p= save_ptr;
int l= cur_level;
int c= cur_group;
int i;
save_ptr= cur_boundary;
while(grp_stack[in_open]!=save_ptr){
decr(cur_level);
tprint_nl("Warning: end of file when ");
print_group(true);
tprint(" is incomplete");
cur_group= save_level(save_ptr);
save_ptr= save_value(save_ptr);
}
save_ptr= p;
cur_level= (quarterword)l;
cur_group= (group_code)c;
p= cond_ptr;
l= if_limit;
c= cur_if;
i= if_line;
while(if_stack[in_open]!=cond_ptr){
tprint_nl("Warning: end of file when ");
print_cmd_chr(if_test_cmd,cur_if);
if(if_limit==fi_code)
tprint_esc("else");
print_if_line(if_line);
tprint(" is incomplete");
if_line= if_line_field(cond_ptr);
cur_if= if_limit_subtype(cond_ptr);
if_limit= if_limit_type(cond_ptr);
cond_ptr= vlink(cond_ptr);
}
cond_ptr= p;
if_limit= l;
cur_if= c;
if_line= i;
print_ln();
if(tracing_nesting_par> 1)
show_context();
if(history==spotless)
history= warning_issued;
}
/* Also does line_3d */
void *snag_line(FILE *fpin, char *s, char *value, int *group, int *type)
{
LineEntity *item;
item = (LineEntity *)malloc(sizeof(LineEntity));
if (!item) {
printf("malloc failed\n");
return NULL;
}
/* common defaults */
common_defaults((void *)item);
/* entity defaults */
/* none */
while (TRUE) {
/*
* Assume that we can read to the next entity group
*/
get_next_group(fpin, REQUIRED, s, value, group, type);
if (is_common(*group)) {
/* common stuff */
handle_common((void *)item, *group, value);
continue;
}
switch (*group) {
/* start */
case G_X_COOR1: item->start[0] = atof(value); break;
case G_Y_COOR1: item->start[1] = atof(value); break;
case G_Z_COOR1: item->start[2] = atof(value); break;
/* end */
case G_X_COOR2: item->end[0] = atof(value); break;
case G_Y_COOR2: item->end[1] = atof(value); break;
case G_Z_COOR2: item->end[2] = atof(value); break;
/* next group */
case G_FILE_SEP:
rewind_file();
return (void *)item;
default:
print_group("Unknown group in LINE", *group, value, IGNORE);
}
}
}
int
main(int argc, char **argv)
{
struct group *gr;
int i;
if (argc != 2) {
fprintf(stderr, "usage: %s user\n", argv[0]);
exit(1);
}
while ((gr = getgrent()) != NULL)
for (i = 0; gr->gr_mem[i] != NULL; i++)
if (strcmp(gr->gr_mem[i], argv[1]) == 0)
print_group(gr);
endgrent();
exit(0);
}
void print_user(t_dnode *temp, t_space *sp)
{
t_passwd *user;
t_value *value;
value = temp->content;
user = getpwuid(value->sb->st_uid);
if (user)
{
ft_putstr(user->pw_name);
space(sp->user - ft_strlen(user->pw_name));
}
else
{
ft_putnbr(value->sb->st_uid);
space(sp->user - nbr_len(value->sb->st_uid));
}
ft_putstr(" ");
print_group(temp, sp);
}
void *snag_point(FILE *fpin, char *s, char *value, int *group, int *type)
{
PointEntity *item;
item = (PointEntity *)malloc(sizeof(PointEntity));
if (!item) {
printf("malloc failed\n");
return NULL;
}
/* common defaults */
common_defaults((void *)item);
/* entity defaults */
item->angle = 0;
while (TRUE) {
/*
* Assume that we can read to the next entity group
*/
get_next_group(fpin, REQUIRED, s, value, group, type);
if (is_common(*group)) {
handle_common((void *)item, *group, value);
continue;
}
switch (*group) {
/* angle */
case G_ANGLE1: item->angle = atof(value); break;
/* PointEntity */
case G_X_COOR1: item->pt[0] = atof(value); break;
case G_Y_COOR1: item->pt[1] = atof(value); break;
case G_Z_COOR1: item->pt[2] = atof(value); break;
/* next group */
case G_FILE_SEP:
rewind_file();
return (void *)item;
default:
print_group("Unknown group in POINT", *group, value, IGNORE);
}
}
}
//-------------------------------------------------------------------------------------------------
void MessageBase::print(ostream& os, int depth) const
{
const string dspacer((depth + 1) * 3, ' ');
const BaseMsgEntry *tbme(_ctx._bme.find_ptr(_msgType));
if (tbme)
os << tbme->_name << " (\"" << _msgType << "\")" << endl;
for (Positions::const_iterator itr(_pos.begin()); itr != _pos.end(); ++itr)
{
const BaseEntry *tbe(_ctx._be.find_ptr(itr->second->_fnum));
if (!tbe)
#if defined PERMIT_CUSTOM_FIELDS
if (!_ctx._ube || (tbe = _ctx._ube->find_ptr(itr->second->_fnum)) == 0)
#endif
throw InvalidField(itr->second->_fnum);
os << dspacer << tbe->_name << " (" << itr->second->_fnum << "): ";
int idx;
if (itr->second->_rlm && (idx = (itr->second->get_rlm_idx())) >= 0)
os << itr->second->_rlm->_descriptions[idx] << " (" << *itr->second << ')' << endl;
else
os << *itr->second << endl;
if (_fp.is_group(itr->second->_fnum))
print_group(itr->second->_fnum, os, depth);
}
}
void list_super2(struct ext2_super_block * sb, FILE *f)
{
int inode_blocks_per_group;
char buf[80], *str;
time_t tm;
inode_blocks_per_group = (((sb->s_inodes_per_group *
EXT2_INODE_SIZE(sb)) +
EXT2_BLOCK_SIZE(sb) - 1) /
EXT2_BLOCK_SIZE(sb));
if (sb->s_volume_name[0]) {
memset(buf, 0, sizeof(buf));
strncpy(buf, sb->s_volume_name, sizeof(sb->s_volume_name));
} else
strcpy(buf, "<none>");
fprintf(f, "Filesystem volume name: %s\n", buf);
if (sb->s_last_mounted[0]) {
memset(buf, 0, sizeof(buf));
strncpy(buf, sb->s_last_mounted, sizeof(sb->s_last_mounted));
} else
strcpy(buf, "<not available>");
fprintf(f, "Last mounted on: %s\n", buf);
fprintf(f, "Filesystem UUID: %s\n", e2p_uuid2str(sb->s_uuid));
fprintf(f, "Filesystem magic number: 0x%04X\n", sb->s_magic);
fprintf(f, "Filesystem revision #: %d", sb->s_rev_level);
if (sb->s_rev_level == EXT2_GOOD_OLD_REV) {
fprintf(f, " (original)\n");
#ifdef EXT2_DYNAMIC_REV
} else if (sb->s_rev_level == EXT2_DYNAMIC_REV) {
fprintf(f, " (dynamic)\n");
#endif
} else
fprintf(f, " (unknown)\n");
print_features(sb, f);
print_super_flags(sb, f);
print_mntopts(sb, f);
fprintf(f, "Filesystem state: ");
print_fs_state (f, sb->s_state);
fprintf(f, "\n");
fprintf(f, "Errors behavior: ");
print_fs_errors(f, sb->s_errors);
fprintf(f, "\n");
str = e2p_os2string(sb->s_creator_os);
fprintf(f, "Filesystem OS type: %s\n", str);
free(str);
fprintf(f, "Inode count: %u\n", sb->s_inodes_count);
fprintf(f, "Block count: %u\n", sb->s_blocks_count);
fprintf(f, "Reserved block count: %u\n", sb->s_r_blocks_count);
fprintf(f, "Free blocks: %u\n", sb->s_free_blocks_count);
fprintf(f, "Free inodes: %u\n", sb->s_free_inodes_count);
fprintf(f, "First block: %u\n", sb->s_first_data_block);
fprintf(f, "Block size: %u\n", EXT2_BLOCK_SIZE(sb));
fprintf(f, "Fragment size: %u\n", EXT2_FRAG_SIZE(sb));
if (sb->s_reserved_gdt_blocks)
fprintf(f, "Reserved GDT blocks: %u\n",
sb->s_reserved_gdt_blocks);
fprintf(f, "Blocks per group: %u\n", sb->s_blocks_per_group);
fprintf(f, "Fragments per group: %u\n", sb->s_frags_per_group);
fprintf(f, "Inodes per group: %u\n", sb->s_inodes_per_group);
fprintf(f, "Inode blocks per group: %u\n", inode_blocks_per_group);
if (sb->s_raid_stride)
fprintf(f, "RAID stride: %u\n",
sb->s_raid_stride);
if (sb->s_raid_stripe_width)
fprintf(f, "RAID stripe width: %u\n",
sb->s_raid_stripe_width);
if (sb->s_first_meta_bg)
fprintf(f, "First meta block group: %u\n",
sb->s_first_meta_bg);
if (sb->s_log_groups_per_flex)
fprintf(f, "Flex block group size: %u\n",
1 << sb->s_log_groups_per_flex);
if (sb->s_mkfs_time) {
tm = sb->s_mkfs_time;
fprintf(f, "Filesystem created: %s", ctime(&tm));
}
tm = sb->s_mtime;
fprintf(f, "Last mount time: %s",
sb->s_mtime ? ctime(&tm) : "n/a\n");
tm = sb->s_wtime;
fprintf(f, "Last write time: %s", ctime(&tm));
fprintf(f, "Mount count: %u\n", sb->s_mnt_count);
fprintf(f, "Maximum mount count: %d\n", sb->s_max_mnt_count);
tm = sb->s_lastcheck;
fprintf(f, "Last checked: %s", ctime(&tm));
fprintf(f, "Check interval: %u (%s)\n", sb->s_checkinterval,
interval_string(sb->s_checkinterval));
if (sb->s_checkinterval)
{
time_t next;
next = sb->s_lastcheck + sb->s_checkinterval;
fprintf(f, "Next check after: %s", ctime(&next));
}
fprintf(f, "Reserved blocks uid: ");
print_user(sb->s_def_resuid, f);
fprintf(f, "Reserved blocks gid: ");
print_group(sb->s_def_resgid, f);
if (sb->s_rev_level >= EXT2_DYNAMIC_REV) {
fprintf(f, "First inode: %d\n", sb->s_first_ino);
fprintf(f, "Inode size: %d\n", sb->s_inode_size);
if (sb->s_min_extra_isize)
fprintf(f, "Required extra isize: %d\n",
sb->s_min_extra_isize);
if (sb->s_want_extra_isize)
fprintf(f, "Desired extra isize: %d\n",
sb->s_want_extra_isize);
}
if (!e2p_is_null_uuid(sb->s_journal_uuid))
fprintf(f, "Journal UUID: %s\n",
e2p_uuid2str(sb->s_journal_uuid));
if (sb->s_journal_inum)
fprintf(f, "Journal inode: %u\n",
sb->s_journal_inum);
if (sb->s_journal_dev)
fprintf(f, "Journal device: 0x%04x\n",
sb->s_journal_dev);
if (sb->s_last_orphan)
fprintf(f, "First orphan inode: %u\n",
sb->s_last_orphan);
if ((sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) ||
sb->s_def_hash_version)
fprintf(f, "Default directory hash: %s\n",
e2p_hash2string(sb->s_def_hash_version));
if (!e2p_is_null_uuid(sb->s_hash_seed))
fprintf(f, "Directory Hash Seed: %s\n",
e2p_uuid2str(sb->s_hash_seed));
if (sb->s_jnl_backup_type) {
fprintf(f, "Journal backup: ");
switch (sb->s_jnl_backup_type) {
case 1:
fprintf(f, "inode blocks\n");
break;
default:
fprintf(f, "type %u\n", sb->s_jnl_backup_type);
}
}
}
static int search_handler(request_rec *r, softbot_handler_rec *s)
{
int rv = 0;
int i = 0, j = 0, cmt_idx = 0, deleted_cnt = 0;
struct timeval tv;
uint32_t start_time = 0, end_time = 0;
char content_type[SHORT_STRING_SIZE+1];
init_server(r, s);
if ( print_elapsed_time ) {
gettimeofday(&tv, NULL);
start_time = tv.tv_sec*1000 + tv.tv_usec/1000;
}
msg_record_init(&s->msg);
set_con_config(r->server);
rv = sb_run_qp_init();
if(rv != SUCCESS && rv != DECLINE) {
MSG_RECORD(&s->msg, error, "qp init failed");
return FAIL;
}
if(apr_table_get(s->parameters_in, "q") == NULL ||
strlen(apr_table_get(s->parameters_in, "q")) == 0) {
MSG_RECORD(&s->msg, error, "Parameter 'q' is null or has zero length. query is null."
" You have to input a valid query or use GET method instead of POST.");
return FAIL;
}
ap_unescape_url((char *)apr_table_get(s->parameters_in, "q"));
rv = sb_run_qp_init_request(&qp_request,
(char *)apr_table_get(s->parameters_in, "q"));
if(rv != SUCCESS) {
error("can not init request");
s->msg = qp_request.msg;
return FAIL;
}
rv = sb_run_qp_init_response(&qp_response);
if(rv != SUCCESS) {
error("can not init request");
return FAIL;
}
//2. get result
timelog("full_search_start");
rv = sb_run_qp_full_search(&qp_request, &qp_response);
timelog("full_search_finish");
if (rv != SUCCESS) {
error("sb_run_qp_full_search failed: query[%s]", qp_request.query);
s->msg = qp_request.msg;
return FAIL;
}
if ( qp_request.is_delete ) {
int i = 0;
int j = 0;
int is_recovery = 0;
if( qp_request.select_list.cnt > 0 &&
qp_request.select_list.field[0].name[0] == '0' ) {
info("recovery deleted document");
is_recovery = 1;
}
for(i = 0; i < qp_response.vdl->cnt; i++) {
for(j = 0; j < qp_response.vdl->data[i].dochit_cnt; j++) {
int rv = 0;
uint32_t docid = qp_response.vdl->data[i].dochits[j].id;
docattr_t* docattr = NULL;
debug("delete docid[%u]", docid);
rv = sb_run_docattr_ptr_get(docid, &docattr);
if ( rv < 0 ) {
error("cannot get docattr of docid[%u]", docid);
continue;
}
if( is_recovery ) {
rv = sb_run_docattr_set_docattr_function(docattr, "Delete", "0");
} else {
rv = sb_run_docattr_set_docattr_function(docattr, "Delete", "1");
}
if ( rv < 0 ) {
error("cannot delete docid[%u]", docid);
continue;
}
deleted_cnt++;
}
}
}
if ( print_elapsed_time ) {
gettimeofday(&tv, NULL);
end_time = tv.tv_sec*1000 + tv.tv_usec/1000;
}
timelog("send_result_start");
snprintf( content_type, SHORT_STRING_SIZE, "text/xml; charset=%s", default_charset);
ap_set_content_type(r, content_type);
ap_rprintf(r, "<?xml version=\"1.0\" encoding=\"%s\"?>\n", default_charset);
ap_rprintf(r,
"<xml>\n"
"<status>1</status>\n"
"<query><![CDATA[%s]]></query>\n"
"<parsed_query><![CDATA[%s]]></parsed_query>\n"
"<result_count>%d</result_count>\n",
qp_request.query,
qp_response.parsed_query,
qp_response.search_result);
if ( qp_request.is_delete ) {
ap_rprintf(r,
"<deleted_count>%d</deleted_count>\n",
deleted_cnt);
}
if(server_id[0] == '\0') {
ap_rprintf(r, "<server_id><![CDATA[%s]]></server_id>\n", get_ipaddress(r->pool));
} else {
ap_rprintf(r, "<server_id><![CDATA[%s]]></server_id>\n", server_id);
}
/* elapsed time */
if ( print_elapsed_time ) {
ap_rprintf(r, "<elapsed_time>%u</elapsed_time>\n", end_time - start_time);
}
/* group result */
ap_rprintf(r, "<groups count=\"%d\">\n", qp_response.groupby_result_vid.rules.cnt);
print_group(r, &qp_response.groupby_result_vid);
ap_rprintf(r, "</groups>\n");
/*
ap_rprintf(r, "<groups type=\"did\">\n");
print_group(r, &qp_response.groupby_result_did);
ap_rprintf(r, "</groups>\n");
*/
if( qp_request.is_delete ) {
} else {
/* each result */
ap_rprintf(r, "<vdocs count=\"%d\">\n", qp_response.vdl->cnt);
for(i = 0; i < qp_response.vdl->cnt; i++) {
virtual_document_t* vd = (virtual_document_t*)&qp_response.vdl->data[i];
ap_rprintf(r, "<vdoc vid=\"%d\" node_id=\"%0X\" relevance=\"%d\">\n",
vd->id, vd->node_id, vd->relevance);
ap_rprintf(r, "<docs count=\"%d\">\n", vd->comment_cnt);
for(j = 0; j < vd->comment_cnt; j++) {
comment_t* cmt = &qp_response.comments[cmt_idx++];
ap_rprintf(r, "<doc doc_id=\"%d\">\n", cmt->did);
if(qp_request.output_style == STYLE_XML) {
ap_rprintf(r, "%s\n", cmt->s);
} else {
ap_rprintf(r, "<![CDATA[%s]]>\n", cmt->s);
}
ap_rprintf(r, "</doc>\n");
}
ap_rprintf(r, "</docs>\n");
ap_rprintf(r, "</vdoc>\n");
}
ap_rprintf(r, "</vdocs>\n");
}
ap_rprintf(r, "</xml>\n");
timelog("send_result_finish");
s->msg = qp_request.msg;
sb_run_qp_finalize_search(&qp_request, &qp_response);
timelog("qp_finalize");
return SUCCESS;
}
