/*
* module initialization function
*/
static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(permissions_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
allow[0].filename = get_pathname(default_allow_file);
allow[0].rules = parse_config_file(allow[0].filename);
if (allow[0].rules) {
LM_DBG("default allow file (%s) parsed\n", allow[0].filename);
} else {
LM_INFO("default allow file (%s) not found => empty rule set\n",
allow[0].filename);
}
deny[0].filename = get_pathname(default_deny_file);
deny[0].rules = parse_config_file(deny[0].filename);
if (deny[0].rules) {
LM_DBG("default deny file (%s) parsed\n", deny[0].filename);
} else {
LM_INFO("default deny file (%s) not found => empty rule set\n",
deny[0].filename);
}
if (init_trusted() != 0) {
LM_ERR("failed to initialize the allow_trusted function\n");
return -1;
}
if (init_tag_avp(&tag_avp_param) < 0) {
LM_ERR("failed to process peer_tag_avp AVP param\n");
return -1;
}
if (init_addresses() != 0) {
LM_ERR("failed to initialize the allow_address function\n");
return -1;
}
if ((db_mode != DISABLE_CACHE) && (db_mode != ENABLE_CACHE)) {
LM_ERR("invalid db_mode value: %d\n", db_mode);
return -1;
}
rules_num = 1;
return 0;
}
/*
* Convert the name of the files into table index
*/
static int load_fixup(void** param, int param_no)
{
char* pathname;
int idx;
rule_file_t* table;
if (param_no == 1) {
table = allow;
} else {
table = deny;
}
pathname = get_pathname(*param);
idx = find_index(table, pathname);
if (idx == -1) {
/* Not opened yet, open the file and parse it */
table[rules_num].filename = pathname;
table[rules_num].rules = parse_config_file(pathname);
if (table[rules_num].rules) {
LM_DBG("file (%s) parsed\n", pathname);
} else {
LM_INFO("file (%s) not parsed properly => empty rule set\n", pathname);
}
*param = (void*)(long)rules_num;
if (param_no == 2) rules_num++;
} else {
/* File already parsed, re-use it */
LM_DBG("file (%s) already loaded, re-using\n", pathname);
pkg_free(pathname);
*param = (void*)(long)idx;
}
return 0;
}
const char *mkpath(const char *fmt, ...)
{
va_list args;
struct strbuf *pathname = get_pathname();
va_start(args, fmt);
strbuf_vaddf(pathname, fmt, args);
va_end(args);
return cleanup_path(pathname->buf);
}
const char *git_common_path(const char *fmt, ...)
{
struct strbuf *pathname = get_pathname();
va_list args;
va_start(args, fmt);
do_git_common_path(pathname, fmt, args);
va_end(args);
return pathname->buf;
}
const char *git_path(const char *fmt, ...)
{
struct strbuf *pathname = get_pathname();
va_list args;
va_start(args, fmt);
do_git_path(the_repository, NULL, pathname, fmt, args);
va_end(args);
return pathname->buf;
}
const char *worktree_git_path(const struct worktree *wt, const char *fmt, ...)
{
struct strbuf *pathname = get_pathname();
va_list args;
va_start(args, fmt);
do_git_path(wt, pathname, fmt, args);
va_end(args);
return pathname->buf;
}
/*
* module initialization function
*/
static int mod_init(void)
{
LM_DBG("initializing...\n");
init_db_url( db_url , 1 /*can be null*/);
address_table.len = strlen(address_table.s);
ip_col.len = strlen(ip_col.s);
proto_col.len = strlen(proto_col.s);
pattern_col.len = strlen(pattern_col.s);
info_col.len = strlen(info_col.s);
grp_col.len = strlen(grp_col.s);
mask_col.len = strlen(mask_col.s);
port_col.len = strlen(port_col.s);
allow[0].filename = get_pathname(default_allow_file);
allow[0].rules = parse_config_file(allow[0].filename);
if (allow[0].rules) {
LM_DBG("default allow file (%s) parsed\n", allow[0].filename);
} else {
LM_INFO("default allow file (%s) not found => empty rule set\n",
allow[0].filename);
}
deny[0].filename = get_pathname(default_deny_file);
deny[0].rules = parse_config_file(deny[0].filename);
if (deny[0].rules) {
LM_DBG("default deny file (%s) parsed\n", deny[0].filename);
} else {
LM_INFO("default deny file (%s) not found => empty rule set\n",
deny[0].filename);
}
if (init_address() != 0) {
LM_ERR("failed to initialize the allow_address function\n");
return -1;
}
rules_num = 1;
return 0;
}
char *git_path(const char *fmt, ...)
{
char *pathname = get_pathname();
va_list args;
char *ret;
va_start(args, fmt);
ret = vsnpath(pathname, PATH_MAX, fmt, args);
va_end(args);
return ret;
}
char *mkpath(const char *fmt, ...)
{
va_list args;
unsigned len;
char *pathname = get_pathname();
va_start(args, fmt);
len = vsnprintf(pathname, PATH_MAX, fmt, args);
va_end(args);
if (len >= PATH_MAX)
return bad_path;
return cleanup_path(pathname);
}
int ACTIVE_TASK::link_user_files() {
PROJECT* project = wup->project;
unsigned int i;
FILE_REF fref;
FILE_INFO* fip;
for (i=0; i<project->user_files.size(); i++) {
fref = project->user_files[i];
fip = fref.file_info;
if (fip->status != FILE_PRESENT) continue;
std::string file_path = get_pathname(fip);
setup_file(project, fip, fref, file_path, slot_dir, true);
}
return 0;
}
int ACTIVE_TASK::copy_output_files() {
for (size_t i = 0; i < result->output_files.size(); ++i) {
FILE_REF& fref = result->output_files[i];
if (!fref.copy_file) {
continue;
}
const FILE_INFO* fip = fref.file_info;
std::string slotfile = slot_dir + std::string("/") + std::string(fref.open_name);
std::string projfile = get_pathname(fip);
int retval = boinc_rename(slotfile.c_str(), projfile.c_str());
if (retval) {
msg_printf(wup->project, MSG_INTERNAL_ERROR, "Can't rename output file %s to %s: %s",
fip->name.c_str(), projfile.c_str(), boincerror(retval));
}
}
return 0;
}
/*
* Test URI against Contact.
*/
int allow_test(char *file, char *uri, char *contact)
{
char *pathname;
int idx;
pathname = get_pathname(file);
if (!pathname) {
LM_ERR("Cannot get pathname of <%s>\n", file);
return 0;
}
idx = find_index(allow, pathname);
if (idx == -1) {
LM_ERR("File <%s> has not been loaded\n", pathname);
pkg_free(pathname);
return 0;
}
pkg_free(pathname);
/* turn off control, allow any routing */
if ((!allow[idx].rules) && (!deny[idx].rules)) {
LM_DBG("No rules => Allowed\n");
return 1;
}
LM_DBG("Looking for URI: %s, Contact: %s\n", uri, contact);
/* rule exists in allow file */
if (search_rule(allow[idx].rules, uri, contact)) {
LM_DBG("Allow rule found => Allowed\n");
return 1;
}
/* rule exists in deny file */
if (search_rule(deny[idx].rules, uri, contact)) {
LM_DBG("Deny rule found => Denied\n");
return 0;
}
LM_DBG("Neither allow or deny rule found => Allowed\n");
return 1;
}
static int
trace_cont(int pid)
{
struct ptrace_lwpinfo lwpinfo;
int status;
if (ptrace(PT_CONTINUE, pid, (caddr_t)1, 0) < 0) {
perror("PT_CONTINUE");
ptrace(PT_KILL, pid, NULL, 0);
return (-1);
}
if (waitpid(pid, &status, 0) == -1) {
perror("waitpid");
return (-1);
}
if (WIFEXITED(status) || WIFSIGNALED(status)) {
wait_info(pid, status, NULL);
return (-1);
}
assert(WIFSTOPPED(status));
assert(WSTOPSIG(status) == SIGTRAP);
if (ptrace(PT_LWPINFO, pid, (caddr_t)&lwpinfo, sizeof(lwpinfo)) < 0) {
perror("PT_LWPINFO");
ptrace(PT_KILL, pid, NULL, 0);
return (-1);
}
wait_info(pid, status, &lwpinfo);
if ((lwpinfo.pl_flags & (PL_FLAG_EXEC | PL_FLAG_SCX)) ==
(PL_FLAG_EXEC | PL_FLAG_SCX))
get_pathname(pid);
if ((lwpinfo.pl_flags & (PL_FLAG_FORKED | PL_FLAG_SCX)) ==
(PL_FLAG_FORKED | PL_FLAG_SCX)) {
printf(TRACE "forked child %d\n", lwpinfo.pl_child_pid);
return (lwpinfo.pl_child_pid);
}
return (0);
}
char* identify_filename(char* i_pathname, unsigned char *tmp_buf, struct ext2_inode* inode, blk_t inode_nr){
struct privat priv ;
char magic_buf[100];
int retval= 0;
priv.count = priv.error = priv.flag = 0;
priv.buf = tmp_buf;
memset(magic_buf,0,100);
if ((inode->i_mode & LINUX_S_IFMT) == LINUX_S_IFREG){
memset(tmp_buf,0,12 * current_fs->blocksize);
// iterate first 12 Data Blocks
retval = local_block_iterate3 ( current_fs, *inode, BLOCK_FLAG_DATA_ONLY, NULL, first_blocks, &priv );
if (priv.count <12){
strncpy(magic_buf, magic_buffer(cookie , tmp_buf,
((inode->i_size < 12 * current_fs->blocksize) ? inode->i_size : (12 * current_fs->blocksize))), 60);
i_pathname = get_pathname(inode_nr, i_pathname, magic_buf, tmp_buf);
}
}
return i_pathname;
}
char *git_path(const char *fmt, ...)
{
const char *git_dir = get_git_dir();
char *pathname = get_pathname();
va_list args;
unsigned len;
len = strlen(git_dir);
if (len > PATH_MAX-100)
return bad_path;
memcpy(pathname, git_dir, len);
if (len && git_dir[len-1] != '/')
pathname[len++] = '/';
va_start(args, fmt);
len += vsnprintf(pathname + len, PATH_MAX - len, fmt, args);
va_end(args);
if (len >= PATH_MAX)
return bad_path;
return cleanup_path(pathname);
}
char *git_path_submodule(const char *path, const char *fmt, ...)
{
char *pathname = get_pathname();
struct strbuf buf = STRBUF_INIT;
const char *git_dir;
va_list args;
unsigned len;
len = strlen(path);
if (len > PATH_MAX-100)
return bad_path;
strbuf_addstr(&buf, path);
if (len && path[len-1] != '/')
strbuf_addch(&buf, '/');
strbuf_addstr(&buf, ".git");
git_dir = read_gitfile(buf.buf);
if (git_dir) {
strbuf_reset(&buf);
strbuf_addstr(&buf, git_dir);
}
strbuf_addch(&buf, '/');
if (buf.len >= PATH_MAX)
return bad_path;
memcpy(pathname, buf.buf, buf.len + 1);
strbuf_release(&buf);
len = strlen(pathname);
va_start(args, fmt);
len += vsnprintf(pathname + len, PATH_MAX - len, fmt, args);
va_end(args);
if (len >= PATH_MAX)
return bad_path;
return cleanup_path(pathname);
}
const char *git_path_submodule(const char *path, const char *fmt, ...)
{
struct strbuf *buf = get_pathname();
const char *git_dir;
va_list args;
strbuf_addstr(buf, path);
if (buf->len && buf->buf[buf->len - 1] != '/')
strbuf_addch(buf, '/');
strbuf_addstr(buf, ".git");
git_dir = read_gitfile(buf->buf);
if (git_dir) {
strbuf_reset(buf);
strbuf_addstr(buf, git_dir);
}
strbuf_addch(buf, '/');
va_start(args, fmt);
strbuf_vaddf(buf, fmt, args);
va_end(args);
strbuf_cleanup_path(buf);
return buf->buf;
}
void Def::
process_xlit ()
{
issue_diag (I_STAGE, false, 0, "processing transliteration\n");
std::size_t nchars = 0;
// used in processing the include directive
int nesting_level = 0;
std::list<std::string> file_list;
while (true) {
next = scanner_.next_token ();
switch (next.token) {
case Scanner::tok_include: {
// extract all file names from the list
std::list<std::string> tmp_list;
while (next.token != Scanner::tok_nl) {
next = scanner_.next_token ();
if (next.token == Scanner::tok_string &&
next.name.size () > 2)
tmp_list.push_back (next.name);
}
// insert this list into the main list - at beginning
file_list.insert (file_list.begin (),
tmp_list.begin (), tmp_list.end ());
// get the top of the list
std::string fname (file_list.front ());
file_list.pop_front ();
// bump up the nesting level
nesting_level++;
// get the full path for the included file and open it
scanner_.open (get_pathname (strip_quotes (fname), next.file));
// get comment char and escape char;
// these informations are stored by the scanner
while ((next = scanner_.next_token ()).token
!= Scanner::tok_xlit_start );
break;
}
case Scanner::tok_sym_name: {
process_xlit_statement (nchars);
break;
}
case Scanner::tok_xlit_end: {
if (nesting_level == 0)
return;
// decrement nesting level, close opened file
nesting_level--;
scanner_.close ();
// check if the list of files is empty or not
if (file_list.empty ())
break;
// if not take the following file and open it
std::string fname (file_list.front ());
file_list.pop_front ();
// bump up the nesting level
nesting_level++;
// get the full path for the included file and open it
scanner_.open (get_pathname (strip_quotes (fname), next.file));
// get comment char and escape char;
// these informations are stored by the scanner
while ((next = scanner_.next_token ()).token
!= Scanner::tok_xlit_start);
}
default:
break;
}
}
issue_diag (I_STAGE, false, 0, "done processing transliteration "
"(%lu tokens, %lu characters)");
}
void Def::process_time ()
{
issue_diag (I_STAGE, false, 0, "processing %s section\n", lc_name);
// nesting level
int nesting_level = 0;
time_def_found_ = true;
while ((next = scanner_.next_token ()).token != Scanner::tok_time) {
switch (next.token) {
case Scanner::tok_end:
next = scanner_.next_token ();
if (next.token == Scanner::tok_time) {
// end of numeric block
if (nesting_level == 0)
return;
--nesting_level;
scanner_.close ();
}
else
issue_diag (E_SYNTAX, true, &next,
"wrong section name in END directive\n");
break;
case Scanner::tok_copy: {
next = scanner_.next_token();
if (next.token != Scanner::tok_string)
issue_diag (E_SYNTAX, true, &next,
"expected string following \"copy\" directive\n");
// bump up the nesting level
++nesting_level;
// open the file
scanner_.open (get_pathname (strip_quotes (next.name), next.file));
// get comment char and escape char;
// these informations are stored by the scanner
while ((next = scanner_.next_token ()).token != Scanner::tok_time) {
// the LC_IDENTIFICATION section may also have a
// LC_TIME token that will mess up the parsing
if (next.token == Scanner::tok_ident) {
while ((next = scanner_.next_token ()).token
!= Scanner::tok_end);
next = scanner_.next_token ();
}
}
break;
}
case Scanner::tok_abday: {
const std::size_t nelems =
sizeof time_st_.abday / sizeof *time_st_.abday;
next = extract_string_array (time_st_.abday,
time_st_.wabday,
nelems);
break;
}
case Scanner::tok_day: {
const std::size_t nelems =
sizeof time_st_.day / sizeof *time_st_.day;
next = extract_string_array (time_st_.day,
time_st_.wday,
nelems);
break;
}
case Scanner::tok_abmon: {
const std::size_t nelems =
sizeof time_st_.abmon / sizeof *time_st_.abmon;
next = extract_string_array (time_st_.abmon,
time_st_.wabmon,
nelems);
break;
}
case Scanner::tok_mon: {
const std::size_t nelems =
sizeof time_st_.mon / sizeof *time_st_.mon;
next = extract_string_array (time_st_.mon,
time_st_.wmon,
nelems);
break;
}
case Scanner::tok_d_t_fmt:
next = scanner_.next_token();
time_st_.d_t_fmt = convert_string (next.name);
time_st_.wd_t_fmt = convert_wstring (next);
break;
case Scanner::tok_d_fmt:
next = scanner_.next_token();
time_st_.d_fmt = convert_string (next.name);
time_st_.wd_fmt = convert_wstring (next);
break;
case Scanner::tok_t_fmt:
next = scanner_.next_token();
time_st_.t_fmt = convert_string (next.name);
time_st_.wt_fmt = convert_wstring (next);
break;
case Scanner::tok_am_pm: {
const std::size_t nelems =
sizeof time_st_.am_pm / sizeof *time_st_.am_pm;
next = extract_string_array (time_st_.am_pm,
time_st_.wam_pm,
nelems);
break;
}
case Scanner::tok_t_fmt_ampm:
next = scanner_.next_token();
time_st_.t_fmt_ampm = convert_string (next.name);
time_st_.wt_fmt_ampm = convert_wstring (next);
break;
// The time_get and time_put facets do not make use of eras or
// alternate digits, so we will ignore this part of the locale
// definition
case Scanner::tok_era:
while ((next = scanner_.next_token()).token == Scanner::tok_string)
parse_era (next);
break;
case Scanner::tok_era_d_fmt:
next = scanner_.next_token();
time_st_.era_d_fmt = convert_string (next.name);
time_st_.wera_d_fmt = convert_wstring (next);
break;
case Scanner::tok_era_t_fmt:
next = scanner_.next_token();
time_st_.era_t_fmt = convert_string (next.name);
time_st_.wera_t_fmt = convert_wstring (next);
break;
case Scanner::tok_era_d_t_fmt:
next = scanner_.next_token();
time_st_.era_d_t_fmt = convert_string (next.name);
time_st_.wera_d_t_fmt = convert_wstring (next);
break;
case Scanner::tok_alt_digits:
while ((next = scanner_.next_token()).token == Scanner::tok_string)
{
alt_digit_t digit;
digit.n_alt_digit = convert_string (next.name);
digit.w_alt_digit = convert_wstring (next);
digit.n_offset = 0;
digit.w_offset = 0;
alt_digits_.push_back (digit);
}
break;
default:
break;
}
}
}
void Def::
process_ctype ()
{
issue_diag (I_STAGE, false, 0, "processing %s section\n", lc_name);
ctype_def_found_ = true;
// used in processing the copy/include directive
int nesting_level = 0;
while ((next = scanner_.next_token()).token != Scanner::tok_ctype) {
switch(next.token) {
case Scanner::tok_copy: {
// when we see the copy directive in the ctype definition we
// are going to either create the shared database and create a
// symbolic link to it, or we are going to create a symbolic link
// to the already existing shared ctype database.
next = scanner_.next_token();
if (next.token != Scanner::tok_string)
issue_diag (E_SYNTAX, true, &next,
"expected string following \"copy\" directive\n");
#if !defined (_WIN32) && !defined (__CYGWIN__)
ctype_symlink_ = true;
// first lets make sure that the ctype database for this
// locale hasn't already been generated
ctype_filename_ = output_name_;
// strip off the last directory
ctype_filename_ = ctype_filename_.substr
(0, ctype_filename_.rfind
(_RWSTD_PATH_SEP, ctype_filename_.length() - 1) + 1);
ctype_filename_ += strip_quotes(next.name);
ctype_filename_ += ".ctype.";
ctype_filename_ += charmap_.get_charmap_name();
std::ifstream f (ctype_filename_.c_str(), std::ios::binary);
if (f) {
// the database exists so simply create a sym link to it
ctype_written_ = true;
f.close();
continue;
}
#endif // !_WIN32 && !__CYGWIN__
// bump up the nesting level
nesting_level++;
issue_diag (I_STAGE, false, 0, "processing copy directive\n");
// open the file
scanner_.open (get_pathname (strip_quotes (next.name), next.file));
// get comment char and escape char;
// these informations are stored by the scanner
while ((next = scanner_.next_token ()).token
!= Scanner::tok_ctype ){
// the LC_IDENTIFICATION section may also have a
// LC_CTYPE token that will mess up the parsing
if (next.token == Scanner::tok_ident) {
while ((next = scanner_.next_token()).token
!= Scanner::tok_end );
next = scanner_.next_token();
}
}
break;
}
case Scanner::tok_nl:
break;
case Scanner::tok_upper:
process_mask (std::ctype_base::upper, "upper");
break;
case Scanner::tok_lower:
process_mask (std::ctype_base::lower, "lower");
break;
case Scanner::tok_alpha:
process_mask (std::ctype_base::alpha, "alpha");
break;
case Scanner::tok_digit:
process_mask (std::ctype_base::digit, "digit");
break;
case Scanner::tok_space:
process_mask (std::ctype_base::space, "space");
break;
case Scanner::tok_cntrl:
process_mask (std::ctype_base::cntrl, "cntrl");
break;
case Scanner::tok_punct:
process_mask (std::ctype_base::punct, "punct");
break;
case Scanner::tok_graph:
process_mask (std::ctype_base::graph, "graph");
break;
case Scanner::tok_print:
process_mask (std::ctype_base::print, "print");
break;
case Scanner::tok_xdigit:
process_mask (std::ctype_base::xdigit, "xdigit");
break;
case Scanner::tok_toupper:
process_upper_lower (Scanner::tok_toupper);
break;
case Scanner::tok_tolower:
process_upper_lower (Scanner::tok_tolower);
break;
case Scanner::tok_blank:
scanner_.ignore_line();
break;
case Scanner::tok_xlit_start:
process_xlit ();
break;
case Scanner::tok_end:
next = scanner_.next_token();
if (next.token == Scanner::tok_ctype) {
// end of ctype block
if (nesting_level == 0)
return;
nesting_level--;
scanner_.close ();
} else
issue_diag (E_SYNTAX, true, &next,
"wrong section name in END directive\n");
break;
default:
// ignore locale specific character classes because the c++
// library does not make use of them
scanner_.ignore_line();
break;
}
}
}
// parse a project's app_info.xml (anonymous platform) file
//
int CLIENT_STATE::parse_app_info(PROJECT* p, FILE* in) {
char buf[256], path[MAXPATHLEN];
MIOFILE mf;
mf.init_file(in);
XML_PARSER xp(&mf);
while (!xp.get_tag()) {
if (xp.match_tag("app_info")) continue;
if (xp.match_tag("/app_info")) {
notices.remove_notices(p, REMOVE_APP_INFO_MSG);
return 0;
}
if (xp.match_tag("file_info") || xp.match_tag("file")) {
FILE_INFO* fip = new FILE_INFO;
if (fip->parse(xp)) {
delete fip;
continue;
}
if (!fip->download_urls.empty() || !fip->upload_urls.empty()) {
msg_printf(p, MSG_INFO,
"Can't specify URLs in app_info.xml"
);
delete fip;
continue;
}
if (link_file_info(p, fip)) {
delete fip;
continue;
}
// check that the file is actually there
//
get_pathname(fip, path, sizeof(path));
if (!boinc_file_exists(path)) {
safe_strcpy(buf,
_("File referenced in app_info.xml does not exist: ")
);
strcat(buf, fip->name);
msg_printf(p, MSG_USER_ALERT, "%s", buf);
delete fip;
continue;
}
fip->status = FILE_PRESENT;
fip->anonymous_platform_file = true;
file_infos.push_back(fip);
continue;
}
if (xp.match_tag("app")) {
APP* app = new APP;
if (app->parse(xp)) {
delete app;
continue;
}
if (lookup_app(p, app->name)) {
delete app;
continue;
}
link_app(p, app);
apps.push_back(app);
continue;
}
if (xp.match_tag("app_version")) {
APP_VERSION* avp = new APP_VERSION;
if (avp->parse(xp)) {
delete avp;
continue;
}
if (cc_config.dont_use_vbox && strstr(avp->plan_class, "vbox")) {
msg_printf(p, MSG_INFO,
"skipping vbox app in app_info.xml; vbox disabled in cc_config.xml"
);
delete avp;
continue;
}
if (strlen(avp->platform) == 0) {
safe_strcpy(avp->platform, get_primary_platform());
}
if (link_app_version(p, avp)) {
delete avp;
continue;
}
app_versions.push_back(avp);
continue;
}
if (log_flags.unparsed_xml) {
msg_printf(p, MSG_INFO,
"Unparsed line in app_info.xml: %s",
xp.parsed_tag
);
}
}
return ERR_XML_PARSE;
}
/*
* module initialization function
*/
static int mod_init(void)
{
if(_perm_load_backends==0) {
LM_ERR("failure - no backend to be loaded\n");
return -1;
}
if(permissions_init_rpc()!=0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
if(_perm_load_backends&PERM_LOAD_ALLOWFILE) {
allow[0].filename = get_pathname(default_allow_file);
allow[0].rules = parse_config_file(allow[0].filename);
if (allow[0].rules) {
LM_DBG("default allow file (%s) parsed\n", allow[0].filename);
} else {
LM_INFO("default allow file (%s) not found => empty rule set\n",
allow[0].filename);
}
} else {
allow[0].filename = NULL;
allow[0].rules = NULL;
}
if(_perm_load_backends&PERM_LOAD_DENYFILE) {
deny[0].filename = get_pathname(default_deny_file);
deny[0].rules = parse_config_file(deny[0].filename);
if (deny[0].rules) {
LM_DBG("default deny file (%s) parsed\n", deny[0].filename);
} else {
LM_INFO("default deny file (%s) not found => empty rule set\n",
deny[0].filename);
}
} else {
deny[0].filename = NULL;
deny[0].rules = NULL;
}
if (init_tag_avp(&tag_avp_param) < 0) {
LM_ERR("failed to process peer_tag_avp AVP param\n");
return -1;
}
if(_perm_load_backends&PERM_LOAD_TRUSTEDDB) {
if (init_trusted() != 0) {
LM_ERR("failed to initialize the allow_trusted function\n");
return -1;
}
}
if(_perm_load_backends&PERM_LOAD_ADDRESSDB) {
if (init_addresses() != 0) {
LM_ERR("failed to initialize the allow_address function\n");
return -1;
}
}
if ((db_mode != DISABLE_CACHE) && (db_mode != ENABLE_CACHE)) {
LM_ERR("invalid db_mode value: %d\n", db_mode);
return -1;
}
rules_num = 1;
return 0;
}
static int
parse_args(const char **cpp, int *pflag, int *lflag, int *iflag,
unsigned long *n_arg, char **path1, char **path2)
{
const char *cmd, *cp = *cpp;
char *cp2;
int base = 0;
long l;
int i, cmdnum;
/* Skip leading whitespace */
cp = cp + strspn(cp, WHITESPACE);
/* Ignore blank lines and lines which begin with comment '#' char */
if (*cp == '\0' || *cp == '#')
return (0);
/* Check for leading '-' (disable error processing) */
*iflag = 0;
if (*cp == '-') {
*iflag = 1;
cp++;
}
/* Figure out which command we have */
for (i = 0; cmds[i].c; i++) {
int cmdlen = strlen(cmds[i].c);
/* Check for command followed by whitespace */
if (!strncasecmp(cp, cmds[i].c, cmdlen) &&
strchr(WHITESPACE, cp[cmdlen])) {
cp += cmdlen;
cp = cp + strspn(cp, WHITESPACE);
break;
}
}
cmdnum = cmds[i].n;
cmd = cmds[i].c;
/* Special case */
if (*cp == '!') {
cp++;
cmdnum = I_SHELL;
} else if (cmdnum == -1) {
error("Invalid command.");
return (-1);
}
/* Get arguments and parse flags */
*lflag = *pflag = *n_arg = 0;
*path1 = *path2 = NULL;
switch (cmdnum) {
case I_GET:
case I_PUT:
if (parse_getput_flags(&cp, pflag))
return(-1);
/* Get first pathname (mandatory) */
if (get_pathname(&cp, path1))
return(-1);
if (*path1 == NULL) {
error("You must specify at least one path after a "
"%s command.", cmd);
return(-1);
}
/* Try to get second pathname (optional) */
if (get_pathname(&cp, path2))
return(-1);
break;
case I_RENAME:
case I_SYMLINK:
if (get_pathname(&cp, path1))
return(-1);
if (get_pathname(&cp, path2))
return(-1);
if (!*path1 || !*path2) {
error("You must specify two paths after a %s "
"command.", cmd);
return(-1);
}
break;
case I_RM:
case I_MKDIR:
case I_RMDIR:
case I_CHDIR:
case I_LCHDIR:
case I_LMKDIR:
/* Get pathname (mandatory) */
if (get_pathname(&cp, path1))
return(-1);
if (*path1 == NULL) {
error("You must specify a path after a %s command.",
cmd);
return(-1);
}
break;
case I_LS:
if (parse_ls_flags(&cp, lflag))
return(-1);
/* Path is optional */
if (get_pathname(&cp, path1))
return(-1);
break;
case I_LLS:
case I_SHELL:
/* Uses the rest of the line */
break;
case I_LUMASK:
base = 8;
case I_CHMOD:
base = 8;
case I_CHOWN:
case I_CHGRP:
/* Get numeric arg (mandatory) */
l = strtol(cp, &cp2, base);
if (cp2 == cp || ((l == LONG_MIN || l == LONG_MAX) &&
errno == ERANGE) || l < 0) {
error("You must supply a numeric argument "
"to the %s command.", cmd);
return(-1);
}
cp = cp2;
*n_arg = l;
if (cmdnum == I_LUMASK && strchr(WHITESPACE, *cp))
break;
if (cmdnum == I_LUMASK || !strchr(WHITESPACE, *cp)) {
error("You must supply a numeric argument "
"to the %s command.", cmd);
return(-1);
}
cp += strspn(cp, WHITESPACE);
/* Get pathname (mandatory) */
if (get_pathname(&cp, path1))
return(-1);
if (*path1 == NULL) {
error("You must specify a path after a %s command.",
cmd);
return(-1);
}
break;
case I_QUIT:
case I_PWD:
case I_LPWD:
case I_HELP:
case I_VERSION:
case I_PROGRESS:
break;
default:
fatal("Command not implemented");
}
*cpp = cp;
return(cmdnum);
}
void Def::process_messages()
{
issue_diag (I_STAGE, false, 0, "processing %s section\n", lc_name);
// nesting level
int nesting_level = 0;
messages_def_found_ = true;
std::string name;
while ((next = scanner_.next_token()).token != Scanner::tok_messages) {
switch(next.token) {
case Scanner::tok_end:
next = scanner_.next_token();
if (next.token == Scanner::tok_messages) {
// end of numeric block
if (nesting_level == 0)
return;
nesting_level--;
scanner_.close ();
} else
issue_diag (E_SYNTAX, true, &next,
"wrong section name in END directive\n");
break;
case Scanner::tok_copy: {
next = scanner_.next_token();
if (next.token != Scanner::tok_string)
issue_diag (E_SYNTAX, true, &next,
"expected string following \"copy\" directive\n");
// bump up the nesting level
nesting_level++;
issue_diag (I_STAGE, false, 0, "processing copy directive\n");
// open the file
scanner_.open (get_pathname (strip_quotes (next.name), next.file));
// get comment char and escape char;
// these informations are stored by the scanner
while ((next = scanner_.next_token ()).token
!= Scanner::tok_messages ){
// the LC_IDENTIFICATION section may also have a
// LC_MESSAGES token that will mess up the parsing
if (next.token == Scanner::tok_ident) {
while ((next = scanner_.next_token()).token
!= Scanner::tok_end );
next = scanner_.next_token();
}
}
break;
}
case Scanner::tok_yesexpr: {
next = scanner_.next_token();
messages_st_.yesexpr = convert_string (next.name);
messages_st_.wyesexpr = convert_wstring (next);
break;
}
case Scanner::tok_noexpr: {
next = scanner_.next_token();
messages_st_.noexpr = convert_string (next.name);
messages_st_.wnoexpr = convert_wstring (next);
break;
}
default:
break;
}
}
}
/// Start a task in a slot directory.
/// This includes setting up soft links,
/// passing preferences, and starting the process.
///
/// Current dir is top-level Synecdoche dir.
///
/// \post
/// - If any error occurs
/// - #task_state is #PROCESS_COULDNT_START
/// - CLIENT_STATE::report_result_error() is called
/// - else
/// - #task_state is #PROCESS_EXECUTING
///
/// \return 0 on success, nonzero otherwise.
int ACTIVE_TASK::start() {
char exec_name[256], exec_path[256];
unsigned int i;
FILE_REF fref;
int retval;
// F*** goto, need to define some variables here instead of where they are used!
std::ostringstream err_stream;
#ifdef _WIN32
std::string cmd_line;
std::string slotdirpath;
#else
// Needs to be defined here because those gotos would skip the
// initialization of 'cmdline' and 'argv' if it would be defined later.
std::ostringstream cmdline;
std::list<std::string> argv;
#endif
if ((!full_init_done) && (log_flags.task)) {
msg_printf(wup->project, MSG_INFO,
"Starting %s", result->name
);
}
if (log_flags.cpu_sched) {
msg_printf(wup->project, MSG_INFO,
"[cpu_sched] Starting %s%s", result->name, (full_init_done) ? " (resume)" : " (initial)"
);
}
// Always check if all required files are present. If not, trigger
// re-downloads and don't start the science application.
FILE_INFO_PSET missing_file_infos;
retval = gstate.input_files_available(result, true, &missing_file_infos);
if (retval) {
for (FILE_INFO_PSET::iterator it = missing_file_infos.begin(); it != missing_file_infos.end(); ++it) {
FILE_INFO* fip = *it;
if (fip) {
err_stream << "Input file " << fip->name
<< " missing or invalid: " << retval;
} else {
err_stream << "Input file missing or invalid";
// We can't trigger a new download if we don't have
// any file information. Just fail here as before.
goto error;
}
fip->status = FILE_NOT_PRESENT;
}
}
if (!missing_file_infos.empty()) {
// Some files are missing and are set for re-transfer.
// Update status and return without error.
result->set_state(RESULT_FILES_DOWNLOADING, "start");
set_task_state(PROCESS_UNINITIALIZED, "start");
next_scheduler_state = PROCESS_UNINITIALIZED;
return 0;
}
if (!full_init_done) {
checkpoint_cpu_time = 0;
checkpoint_wall_time = gstate.now;
}
current_cpu_time = checkpoint_cpu_time;
episode_start_cpu_time = checkpoint_cpu_time;
debt_interval_start_cpu_time = checkpoint_cpu_time;
graphics_request_queue.init(result->name); // reset message queues
process_control_queue.init(result->name);
if (!app_client_shm.shm) {
retval = get_shmem_seg_name();
if (retval) {
err_stream << "Can't get shared memory segment name: " << boincerror(retval);
goto error;
}
}
// this must go AFTER creating shmem name,
// since the shmem name is part of the file
//
retval = write_app_init_file();
if (retval) {
err_stream << "Can't write init file: " << retval;
goto error;
}
// set up applications files
//
strcpy(exec_name, "");
for (i=0; i<app_version->app_files.size(); i++) {
fref = app_version->app_files[i];
FILE_INFO* fip = fref.file_info;
std::string file_path = get_pathname(fip);
if (fref.main_program) {
if (is_image_file(fip->name)) {
err_stream << "Main program " << fip->name << " is an image file";
retval = ERR_NO_SIGNATURE;
goto error;
}
if (!fip->executable && !wup->project->anonymous_platform) {
err_stream << "Main program " << fip->name << " is not executable";
retval = ERR_NO_SIGNATURE;
goto error;
}
safe_strcpy(exec_name, fip->name.c_str());
safe_strcpy(exec_path, file_path.c_str());
}
// anonymous platform may use different files than
// when the result was started, so link files even if not first time
if ((!full_init_done) || (wup->project->anonymous_platform)) {
retval = setup_file(result->project, fip, fref, file_path, slot_dir, true);
if (retval) {
err_stream << "Can't link input file";
goto error;
}
}
}
if (!strlen(exec_name)) {
err_stream << "No main program specified";
retval = ERR_NOT_FOUND;
goto error;
}
// set up input, output files
if (!full_init_done) {
for (i=0; i<wup->input_files.size(); i++) {
fref = wup->input_files[i];
const FILE_INFO* fip = fref.file_info;
std::string file_path = get_pathname(fref.file_info);
retval = setup_file(result->project, fip, fref, file_path, slot_dir, true);
if (retval) {
err_stream << "Can't link input file";
goto error;
}
}
for (i=0; i<result->output_files.size(); i++) {
fref = result->output_files[i];
if (fref.copy_file) continue;
const FILE_INFO* fip = fref.file_info;
std::string file_path = get_pathname(fref.file_info);
retval = setup_file(result->project, fip, fref, file_path, slot_dir, false);
if (retval) {
err_stream << "Can't link output file";
goto error;
}
}
full_init_done = true;
}
link_user_files();
if (gstate.exit_before_start) {
exit(0);
}
#ifdef _WIN32
PROCESS_INFORMATION process_info;
STARTUPINFO startup_info;
LPVOID environment_block = NULL;
char error_msg[1024];
char error_msg2[1024];
memset(&process_info, 0, sizeof(process_info));
memset(&startup_info, 0, sizeof(startup_info));
startup_info.cb = sizeof(startup_info);
// suppress 2-sec rotating hourglass cursor on startup
//
startup_info.dwFlags = STARTF_FORCEOFFFEEDBACK;
app_client_shm.reset_msgs();
if (config.run_apps_manually) {
// fill in core client's PID so we won't think app has exited
pid = GetCurrentProcessId();
pid_handle = GetCurrentProcess();
set_task_state(PROCESS_EXECUTING, "start");
return 0;
}
// NOTE: in Windows, stderr is redirected in boinc_init_diagnostics();
cmd_line = exec_path + std::string(" ") + wup->command_line;
if (strlen(app_version->cmdline)) {
cmd_line += std::string(" ") + app_version->cmdline;
}
slotdirpath = relative_to_absolute(slot_dir);
bool success = false;
for (i=0; i<5; i++) {
if (sandbox_account_service_token != NULL) {
// Find CreateEnvironmentBlock/DestroyEnvironmentBlock pointers
tCEB pCEB = NULL;
tDEB pDEB = NULL;
HMODULE hUserEnvLib = NULL;
hUserEnvLib = LoadLibrary("userenv.dll");
if (hUserEnvLib) {
pCEB = (tCEB) GetProcAddress(hUserEnvLib, "CreateEnvironmentBlock");
pDEB = (tDEB) GetProcAddress(hUserEnvLib, "DestroyEnvironmentBlock");
}
if (!pCEB(&environment_block, sandbox_account_service_token, FALSE)) {
if (log_flags.task) {
windows_error_string(error_msg, sizeof(error_msg));
msg_printf(wup->project, MSG_INFO,
"Process environment block creation failed: %s", error_msg
);
}
}
if (CreateProcessAsUser(
sandbox_account_service_token,
exec_path,
(LPSTR)cmd_line.c_str(),
NULL,
NULL,
FALSE,
CREATE_NEW_PROCESS_GROUP|CREATE_NO_WINDOW|IDLE_PRIORITY_CLASS|CREATE_UNICODE_ENVIRONMENT,
environment_block,
slotdirpath.c_str(),
&startup_info,
&process_info
)) {
success = true;
break;
} else {
windows_error_string(error_msg, sizeof(error_msg));
msg_printf(wup->project, MSG_INTERNAL_ERROR,
"Process creation failed: %s", error_msg
);
}
if (!pDEB(environment_block)) {
if (log_flags.task) {
windows_error_string(error_msg, sizeof(error_msg2));
msg_printf(wup->project, MSG_INFO,
"Process environment block cleanup failed: %s",
error_msg2
);
}
}
if (hUserEnvLib) {
pCEB = NULL;
pDEB = NULL;
FreeLibrary(hUserEnvLib);
}
} else {
if (CreateProcess(
exec_path,
(LPSTR)cmd_line.c_str(),
NULL,
NULL,
FALSE,
CREATE_NEW_PROCESS_GROUP|CREATE_NO_WINDOW|IDLE_PRIORITY_CLASS,
NULL,
slotdirpath.c_str(),
&startup_info,
&process_info
)) {
success = true;
break;
} else {
windows_error_string(error_msg, sizeof(error_msg));
msg_printf(wup->project, MSG_INTERNAL_ERROR,
"Process creation failed: %s", error_msg
);
}
}
boinc_sleep(drand());
}
if (!success) {
err_stream << "CreateProcess() failed - " << error_msg;
retval = ERR_EXEC;
goto error;
}
pid = process_info.dwProcessId;
pid_handle = process_info.hProcess;
CloseHandle(process_info.hThread); // thread handle is not used
#else
// Unix/Linux/Mac case
// Set up core/app shared memory seg if needed
//
if (!app_client_shm.shm) {
if (app_version->api_major_version() >= 6) {
// Use mmap() shared memory
std::string buf = slot_dir + std::string("/") + std::string(MMAPPED_FILE_NAME);
if (g_use_sandbox) {
if (!boinc_file_exists(buf.c_str())) {
int fd = open(buf.c_str(), O_RDWR | O_CREAT, 0660);
if (fd >= 0) {
close (fd);
#ifdef SANDBOX
set_to_project_group(buf.c_str());
#endif
}
}
}
retval = create_shmem_mmap(
buf.c_str(), sizeof(SHARED_MEM), (void**)&app_client_shm.shm
);
} else {
// Use shmget() shared memory
retval = create_shmem(
shmem_seg_name, sizeof(SHARED_MEM), gstate.boinc_project_gid,
(void**)&app_client_shm.shm
);
if (retval) {
needs_shmem = true;
destroy_shmem(shmem_seg_name);
return retval;
}
}
needs_shmem = false;
}
app_client_shm.reset_msgs();
#if (defined (__APPLE__) && (defined(__i386__) || defined(__x86_64__)))
// PowerPC apps emulated on i386 Macs crash if running graphics
powerpc_emulated_on_i386 = ! is_native_i386_app(exec_path);
#endif
if (config.run_apps_manually) {
pid = getpid(); // use the client's PID
set_task_state(PROCESS_EXECUTING, "start");
return 0;
}
// Prepare command line for the science app:
cmdline << wup->command_line;
if (strlen(app_version->cmdline)) {
cmdline << ' ' << app_version->cmdline;
}
argv = parse_command_line(cmdline.str().c_str());
if (log_flags.task_debug) {
debug_print_argv(argv);
}
pid = fork();
if (pid == -1) {
err_stream << "fork() failed: " << strerror(errno);
retval = ERR_FORK;
goto error;
}
if (pid == 0) {
// from here on we're running in a new process.
// If an error happens,
// exit nonzero so that the core client knows there was a problem.
// don't pass stdout to the app
//
int fd = open("/dev/null", O_RDWR);
dup2(fd, STDOUT_FILENO);
close(fd);
// add to library path:
// - the project dir (../../projects/X)
// - the slot dir (.)
// - the Synecdoche dir (../..)
// We use relative paths in case higher-level dirs
// are not readable to the account under which app runs
//
std::string pdir = get_project_dir(wup->project);
std::ostringstream libpath;
const char* env_lib_path = getenv("LD_LIBRARY_PATH");
if (env_lib_path) {
libpath << env_lib_path << ':';
}
libpath << "../../" << pdir << ":.:../..";
setenv("LD_LIBRARY_PATH", libpath.str().c_str(), 1);
retval = chdir(slot_dir.c_str());
if (retval) {
perror("chdir");
fflush(NULL);
_exit(errno);
}
#if 0
// set stack size limit to the max.
// Some BOINC apps have reported problems with exceeding
// small stack limits (e.g. 8 MB)
// and it seems like the best thing to raise it as high as possible
//
struct rlimit rlim;
#define MIN_STACK_LIMIT 64000000
getrlimit(RLIMIT_STACK, &rlim);
if (rlim.rlim_cur != RLIM_INFINITY && rlim.rlim_cur <= MIN_STACK_LIMIT) {
if (rlim.rlim_max == RLIM_INFINITY || rlim.rlim_max > MIN_STACK_LIMIT) {
rlim.rlim_cur = MIN_STACK_LIMIT;
} else {
rlim.rlim_cur = rlim.rlim_max;
}
setrlimit(RLIMIT_STACK, &rlim);
}
#endif
// hook up stderr to a specially-named file
//
freopen(STDERR_FILE, "a", stderr);
// set idle process priority
#ifdef HAVE_SETPRIORITY
if (setpriority(PRIO_PROCESS, 0, PROCESS_IDLE_PRIORITY)) {
perror("setpriority");
}
#endif
std::string path = std::string("../../") + std::string(exec_path);
if (g_use_sandbox) {
std::ostringstream switcher_path;
switcher_path << "../../" << SWITCHER_DIR << '/' << SWITCHER_FILE_NAME;
argv.push_front(exec_name);
argv.push_front(path);
argv.push_front(SWITCHER_FILE_NAME);
// Files written by projects have user boinc_project and group boinc_project,
// so they must be world-readable so Synecdoche can read them.
umask(2);
retval = do_execv(switcher_path.str(), argv);
} else {
argv.push_front(exec_name);
retval = do_execv(path, argv);
}
msg_printf(wup->project, MSG_INTERNAL_ERROR,
"Process creation (%s) failed: %s, errno=%d\n", path.c_str(), boincerror(retval), errno
);
perror("execv");
fflush(NULL);
_exit(errno);
}
if (log_flags.task_debug) {
msg_printf(wup->project, MSG_INFO,
"[task_debug] ACTIVE_TASK::start(): forked process: pid %d\n", pid
);
}
#endif
set_task_state(PROCESS_EXECUTING, "start");
return 0;
// go here on error; "error_msg" contains error message, "retval" is nonzero
//
error:
// if something failed, it's possible that the executable was munged.
// Verify it to trigger another download.
//
gstate.input_files_available(result, true);
gstate.report_result_error(*result, "%s", err_stream.str().c_str());
set_task_state(PROCESS_COULDNT_START, "start");
return retval;
}
/*
* For each tracefile, we first create in-memory structures, then once
* we've processed each tracefile completely, we write out the in-memory
* structures and free them.
*/
int main(int argc, char **argv)
{
FILE *fp;
char path[512];
char syscall[512];
char lseek_action_str[512];
char *s;
char open_flags_str[64];
void *db_node;
int num_io_operations = 0;
struct ioshark_header header;
struct ioshark_file_operation *disk_file_op;
struct in_mem_file_op *in_mem_fop;
struct stat st;
char *infile, *outfile;
struct timeval prev_time;
char trace_type[64];
progname = argv[0];
if (argc != 3) {
usage();
exit(EXIT_FAILURE);
}
infile = argv[1];
outfile = argv[2];
if (stat(infile, &st) < 0) {
fprintf(stderr, "%s Can't stat %s\n",
progname, infile);
exit(EXIT_FAILURE);
}
if (st.st_size == 0) {
fprintf(stderr, "%s Empty file %s\n",
progname, infile);
exit(EXIT_FAILURE);
}
init_prev_time(&prev_time);
init_filename_cache();
fp = fopen(infile, "r");
if (fp == NULL) {
fprintf(stderr, "%s Can't open %s\n",
progname, infile);
exit(EXIT_FAILURE);
}
while (fgets(in_buf, 2048, fp)) {
s = in_buf;
while (isspace(*s))
s++;
in_mem_fop = malloc(sizeof(struct in_mem_file_op));
disk_file_op = &in_mem_fop->disk_file_op;
disk_file_op->delta_us = get_delta_ts(s, &prev_time);
get_tracetype(s, trace_type);
if (strcmp(trace_type, "strace") == 0) {
get_syscall(s, syscall);
disk_file_op->file_op = map_syscall(syscall);
} else
disk_file_op->file_op = map_syscall("ftrace");
get_pathname(s, path, disk_file_op->file_op);
db_node = files_db_add(path);
disk_file_op->fileno = files_db_get_fileno(db_node);
switch (disk_file_op->file_op) {
case IOSHARK_LLSEEK:
case IOSHARK_LSEEK:
get_lseek_offset_action(s,
disk_file_op->file_op,
&disk_file_op->lseek_offset,
lseek_action_str);
disk_file_op->lseek_action =
map_lseek_action(lseek_action_str);
if (disk_file_op->lseek_action == SEEK_SET)
files_db_update_size(db_node,
disk_file_op->lseek_offset);
break;
case IOSHARK_PREAD64:
case IOSHARK_PWRITE64:
get_prw64_offset_len(s,
&disk_file_op->prw_offset,
(u_int64_t *)&disk_file_op->prw_len);
files_db_update_size(db_node,
disk_file_op->prw_offset +
disk_file_op->prw_len);
break;
case IOSHARK_READ:
case IOSHARK_WRITE:
get_rw_len(s, (u_int64_t *)&disk_file_op->rw_len);
files_db_add_to_size(db_node,
disk_file_op->rw_len);
break;
case IOSHARK_MMAP:
case IOSHARK_MMAP2:
get_mmap_offset_len_prot(s,
&disk_file_op->mmap_prot,
&disk_file_op->mmap_offset,
(u_int64_t *)&disk_file_op->mmap_len);
files_db_update_size(db_node,
disk_file_op->mmap_offset +
disk_file_op->mmap_len);
break;
case IOSHARK_OPEN:
disk_file_op->open_mode = 0;
get_openat_flags_mode(s, open_flags_str,
&disk_file_op->open_mode);
disk_file_op->open_flags =
map_open_flags(open_flags_str);
break;
case IOSHARK_FSYNC:
case IOSHARK_FDATASYNC:
break;
case IOSHARK_CLOSE:
break;
case IOSHARK_MAPPED_PREAD:
/* Convert a mmap'ed read into a PREAD64 */
disk_file_op->file_op = IOSHARK_PREAD64;
get_ftrace_offset_len(s,
&disk_file_op->prw_offset,
(u_int64_t *)&disk_file_op->prw_len);
files_db_update_size(db_node,
disk_file_op->prw_offset +
disk_file_op->prw_len);
break;
default:
break;
}
/* Chain at the end */
num_io_operations++;
in_mem_fop->next = NULL;
if (in_mem_file_op_head == NULL) {
in_mem_file_op_tail = in_mem_fop;
in_mem_file_op_head = in_mem_fop;
} else {
in_mem_file_op_tail->next = in_mem_fop;
in_mem_file_op_tail = in_mem_fop;
}
}
fclose(fp);
/*
* Now we can write everything out to the output tracefile.
*/
fp = fopen(outfile, "w+");
if (fp == NULL) {
fprintf(stderr, "%s Can't open trace.outfile\n",
progname);
exit(EXIT_FAILURE);
}
header.num_io_operations = num_io_operations;
header.num_files = files_db_get_total_obj();
if (fwrite(&header, sizeof(struct ioshark_header), 1, fp) != 1) {
fprintf(stderr, "%s Write error trace.outfile\n",
progname);
exit(EXIT_FAILURE);
}
files_db_write_objects(fp);
while (in_mem_file_op_head != NULL) {
struct in_mem_file_op *temp;
disk_file_op = &in_mem_file_op_head->disk_file_op;
if (fwrite(disk_file_op,
sizeof(struct ioshark_file_operation), 1, fp) != 1) {
fprintf(stderr, "%s Write error trace.outfile\n",
progname);
exit(EXIT_FAILURE);
}
temp = in_mem_file_op_head;
in_mem_file_op_head = in_mem_file_op_head->next;
free(temp);
}
store_filename_cache();
}
