void set_gadget_filename(gadget_read_info *fp_gadget, int multifile_number, char *filename) {
// Determine/set the filename root and path
char filename_root[SID_MAX_FILENAME_LENGTH];
char filename_path[SID_MAX_FILENAME_LENGTH];
strcpy(filename_root, fp_gadget->filename_root);
strip_path(filename_root);
if(strlen(filename_root) == 0)
sprintf(filename_root, "snapshot");
strcpy(filename_path, fp_gadget->filename_root);
strip_file_root(filename_path);
if(fp_gadget->flag_file_type == 0)
sprintf(filename, "%s/%s_%03d/%s_%03d", filename_path, filename_root, fp_gadget->snapshot_number, filename_root, fp_gadget->snapshot_number);
else if(fp_gadget->flag_file_type == 1)
sprintf(filename, "%s/%s_%03d", filename_path, filename_root, fp_gadget->snapshot_number);
else if(fp_gadget->flag_file_type == 2)
sprintf(filename, "%s/%s", filename_path, filename_root);
else if(fp_gadget->flag_file_type == 3)
sprintf(filename, "%s_%03d", fp_gadget->filename_root, fp_gadget->snapshot_number);
else if(fp_gadget->flag_file_type == 4)
sprintf(filename, "%s", fp_gadget->filename_root);
if(fp_gadget->flag_multifile)
sprintf(filename, "%s.%d", filename, multifile_number);
}
static DBusMessage *agent_report_error(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct agent_data *request = user_data;
DBusMessageIter iter;
char *path, *service, *error;
if (handle_message(message, request, agent_report_error) == false)
return NULL;
dbus_message_iter_init(message, &iter);
dbus_message_iter_get_basic(&iter, &path);
service = strip_path(path);
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter, &error);
__connmanctl_save_rl();
if (strcmp(request->interface, AGENT_INTERFACE) == 0)
fprintf(stdout, "Agent ReportError %s\n", service);
else
fprintf(stdout, "VPN Agent ReportError %s\n", service);
fprintf(stdout, " %s\n", error);
__connmanctl_redraw_rl();
request->message = dbus_message_ref(message);
__connmanctl_agent_mode("Retry (yes/no)? ", report_error_return,
request);
return NULL;
}
static DBusMessage *agent_report_peer_error(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct agent_data *request = user_data;
char *path, *peer, *error;
DBusMessageIter iter;
if (handle_message(message, request,
agent_report_peer_error) == false)
return NULL;
dbus_message_iter_init(message, &iter);
dbus_message_iter_get_basic(&iter, &path);
peer = strip_path(path);
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter, &error);
__connmanctl_save_rl();
fprintf(stdout, "Agent ReportPeerError %s\n", peer);
fprintf(stdout, " %s\n", error);
__connmanctl_redraw_rl();
request->message = dbus_message_ref(message);
__connmanctl_agent_mode("Retry (yes/no)? ",
report_error_return, request);
return NULL;
}
static DBusMessage *agent_request_browser(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct agent_data *request = user_data;
DBusMessageIter iter;
char *service, *url;
if (handle_message(message, request, agent_request_browser) == false)
return NULL;
dbus_message_iter_init(message, &iter);
dbus_message_iter_get_basic(&iter, &service);
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter, &url);
__connmanctl_save_rl();
fprintf(stdout, "Agent RequestBrowser %s\n", strip_path(service));
fprintf(stdout, " %s\n", url);
__connmanctl_redraw_rl();
request->message = dbus_message_ref(message);
__connmanctl_agent_mode("Connected (yes/no)? ",
request_browser_return, request);
return NULL;
}
PUBLIC int search_file(char *path)
{
/* 获得文件所在目录的 inode */
char filename[MAX_PATH];
memset(filename, 0, MAX_FILENAME_LEN);
struct inode *dir_inode;
if (strip_path(filename, path, &dir_inode) != 0)
return 0;
if (filename[0] == 0)
return dir_inode->i_num;
/* 根据这个 inode 找到对应扇区 */
int dir_blk0_nr = dir_inode->i_start_sect; // 目录起始扇区
int nr_dir_blks = (dir_inode->i_size + SECTOR_SIZE - 1) / SECTOR_SIZE; // 占用几个扇区（至少一个）
int nr_dir_entries = dir_inode->i_size / DIR_ENTRY_SIZE; // 一共有几个条目
int m = 0;
struct dir_entry *pde;
for (int i = 0; i < nr_dir_blks; i++) {
RD_SECT(dir_inode->i_dev, dir_blk0_nr + i);
pde = (struct dir_entry *)fsbuf;
for (int j = 0; j < SECTOR_SIZE / DIR_ENTRY_SIZE; j++, pde++) {
if (memcmp(filename, pde->name, MAX_FILENAME_LEN) == 0)
return pde->inode_nr; // 文件存在
if (++m > nr_dir_entries)
break;
}
if (m > nr_dir_entries)
break;
}
return 0; // 文件不存在
}
/* Function that checks whether we need to mask the specified pid */
int should_mask(const char *name)
{
char *stripped = strip_path(name);
char *res = strstr(stripped, PREF);
return (res == stripped) ? 1 : 0;
}
void set_smooth_filename(char *filename_root_in,int snapshot_number,int multifile_number,int flag_multifile,int flag_file_type,char *filename){
char filename_root[MAX_FILENAME_LENGTH];
char filename_path[MAX_FILENAME_LENGTH];
// Determine/set the filename root and path
strcpy(filename_root,filename_root_in);
strip_path(filename_root);
if(strlen(filename_root)==0)
sprintf(filename_root,"smooth");
strcpy(filename_path,filename_root_in);
strip_file_root(filename_path);
if(flag_file_type==0)
sprintf(filename,"%s/%s_%03d/%s_%03d",filename_path,filename_root,snapshot_number,filename_root,snapshot_number);
else if(flag_file_type==1)
sprintf(filename,"%s/%s_%03d",filename_path,filename_root,snapshot_number);
else if(flag_file_type==2)
sprintf(filename,"%s/%s",filename_path,filename_root);
else if(flag_file_type==3)
sprintf(filename,"%s_%03d",filename_root_in,snapshot_number);
else if(flag_file_type==4)
sprintf(filename,"%s",filename_root_in);
if(flag_multifile)
sprintf(filename,"%s.%d",filename,multifile_number);
}
static BOOL do_create(MESSAGE *message){
const char *path;
char dirname[MAX_FILENAME_LENGTH]={0};
char filename[MAX_FILENAME_LENGTH]={0};
int flags,inode_index;
path=message->arg_pointer;
flags=message->flags;
//分离父目录路径和文件名
if(!strip_path(path,dirname,filename)){
return FALSE;
}
inode_index=search_file(dirname,filename,GET_FILE_TYPE(flags));
if(inode_index<0){
inode_index=create_file(dirname,filename,GET_FILE_TYPE(flags));
if(inode_index<0){
return FALSE;
}
}
else{
set_error_index(FILE_EXIST);
return FALSE;
}
return TRUE;
}
static DBusMessage *
agent_request_peer_authorization(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct agent_data *request = user_data;
DBusMessageIter iter, dict;
char *peer, *str;
bool input;
int i;
if (handle_message(message, request, agent_request_peer_authorization)
== false)
return NULL;
dbus_message_iter_init(message, &iter);
dbus_message_iter_get_basic(&iter, &str);
peer = strip_path(str);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &dict);
__connmanctl_save_rl();
fprintf(stdout, "Agent RequestPeerAuthorization %s\n", peer);
__connmanctl_dbus_print(&dict, " ", " = ", "\n");
fprintf(stdout, "\n");
parse_agent_request(request, &iter);
for (input = false, i = 0; request->input[i].attribute; i++) {
if (request->input[i].requested == true) {
input = true;
break;
}
}
if (!input) {
request->message = dbus_message_ref(message);
__connmanctl_agent_mode("Accept connection (yes/no)? ",
request_authorization_return, request);
return NULL;
}
request->reply = dbus_message_new_method_return(message);
dbus_message_iter_init_append(request->reply, &request->iter);
dbus_message_iter_open_container(&request->iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
&request->dict);
request_input_next(request);
return NULL;
}
void sleep_tracker_lock(const char* const filename, int line)
{
const char* const stripped_path = strip_path(filename);
sleep_statistic_t* stat = sleep_tracker_find(stripped_path);
// Entry for this driver does not exist, create one.
if (stat == NULL) {
stat = sleep_tracker_add(stripped_path);
}
core_util_atomic_incr_u8(&stat->count, 1);
debug("LOCK: %s, ln: %i, lock count: %u\r\n", stripped_path, line, deep_sleep_lock);
}
void sleep_tracker_unlock(const char* const filename, int line)
{
const char* const stripped_path = strip_path(filename);
sleep_statistic_t* stat = sleep_tracker_find(stripped_path);
// Entry for this driver does not exist, something went wrong.
if (stat == NULL) {
debug("Unlocking sleep for driver that was not previously locked: %s, ln: %i\r\n", stripped_path, line);
return;
}
core_util_atomic_decr_u8(&stat->count, 1);
debug("UNLOCK: %s, ln: %i, lock count: %u\r\n", stripped_path, line, deep_sleep_lock);
}
/*****************************************************************************
* do_stat
*************************************************************************//**
* Perform the stat() syscall.
*
* @return On success, zero is returned. On error, -1 is returned.
*****************************************************************************/
PUBLIC int do_stat()
{
char pathname[MAX_PATH]; /* parameter from the caller */
char filename[MAX_PATH]; /* directory has been stipped */
/* get parameters from the message */
int name_len = fs_msg.NAME_LEN; /* length of filename */
int src = fs_msg.source; /* caller proc nr. */
assert(name_len < MAX_PATH);
phys_copy((void*)va2la(TASK_FS, pathname), /* to */
(void*)va2la(src, fs_msg.PATHNAME), /* from */
name_len);
pathname[name_len] = 0; /* terminate the string */
int inode_nr = search_file(pathname);
if (inode_nr == INVALID_INODE) { /* file not found */
printl("{FS} FS::do_stat():: search_file() returns "
"invalid inode: %s\n", pathname);
return -1;
}
struct inode * pin = 0;
struct inode * dir_inode;
if (strip_path(filename, pathname, &dir_inode) != 0) {
/* theoretically never fail here
* (it would have failed earlier when
* search_file() was called)
*/
assert(0);
}
pin = get_inode(dir_inode->i_dev, inode_nr);
struct stat s; /* the thing requested */
s.st_dev = pin->i_dev;
s.st_ino = pin->i_num;
s.st_mode= pin->i_mode;
s.st_rdev= is_special(pin->i_mode) ? pin->i_start_sect : NO_DEV;
s.st_size= pin->i_size;
put_inode(pin);
phys_copy((void*)va2la(src, fs_msg.BUF), /* to */
(void*)va2la(TASK_FS, &s), /* from */
sizeof(struct stat));
return 0;
}
PRIVATE struct inode* create_file(char* path, int flags) {
char filename[MAX_PATH];
struct inode* dir_inode;
if (strip_path(filename, path, &dir_inode) != 0)
return 0;
int inode_nr = alloc_imap_bit(dir_inode -> i_dev);
int free_sect_nr = alloc_smap_bit(dir_inode -> i_dev, NR_DEFAULT_FILE_SECTS);
struct inode* nd = new_inode(dir_inode -> i_dev, inode_nr, free_sect_nr);
new_dir_entry(dir_inode, nd -> i_num, filename);
return nd;
}
/**************************************************************************************************
* create_file
**************************************************************************************************
* Create a file and return it's inode pointer.
*
* @param path The full path of the new file.
* @param flags Attributes of the new file.
*
* @return Pointer to inode of the new file if successed, otherwise 0.
*************************************************************************************************/
PRIVATE struct inode* create_file(char* path, int flags){
char filename[MAX_PATH];
struct inode* dir_inode;
if(strip_path(filename, path, &dir_inode) != 0){
return 0;
}
int nr_inode = alloc_imap_bit(dir_inode->i_dev);
/* one file at least is 1MB... */
int nr_free_sect = alloc_smap_bit(dir_inode->i_dev, NR_DEFAULT_FILE_SECTS);
struct inode* newino = new_inode(dir_inode->i_dev, nr_inode, nr_free_sect);
new_dir_entry(dir_inode, newino->i_num, filename);
return newino;
}
PUBLIC int do_stat() {
char pathname[MAX_PATH];
char filename[MAX_PATH];
int name_len = fs_msg.NAME_LEN;
int src = fs_msg.source;
memcpy((void*)va2la(TASK_FS, pathname),
(void*)va2la(src, fs_msg.PATHNAME),
name_len);
pathname[name_len] = 0;
int inode_nr = search_file(pathname);
if (inode_nr == INVALID_INODE) {
printl("FS::do_stat() failed, search file %s return INVALID INODE.\n", pathname);
return -1;
}
struct inode* pin = 0;
struct inode* dir_inode = 0;
if(strip_path(filename, pathname, &dir_inode) != 0) {
assert(0);
}
pin = get_inode(dir_inode -> i_dev, inode_nr);
struct stat s;
s.st_dev = pin -> i_dev;
s.st_ino = pin -> i_num;
s.st_mode = pin -> i_mode;
s.st_rdev = pin -> i_mode == I_CHAR_SPECIAL ? pin -> i_start_sect : NO_DEV;
s.st_size = pin -> i_size;
put_inode(pin);
memcpy((void*)va2la(src, fs_msg.BUF),
(void*)va2la(TASK_FS, &s),
sizeof(struct stat));
return 0;
}
/**
* Search the file and return the inode_nr.
*
* @param[in] path The full path of the file to search.
* @return Ptr to the i-node of the file if successful, otherwise zero.
*
* @see open()
* @see do_open()
*****************************************************************************/
PUBLIC int search_file(char * path)
{
int i, j;
char filename[MAX_PATH];
memset(filename, 0, MAX_FILENAME_LEN);
struct inode * dir_inode;
if (strip_path(filename, path, &dir_inode) != 0)
return 0;
if (filename[0] == 0) /* path: "/" */
return dir_inode->i_num;
/**
* Search the dir for the file.
*/
int dir_blk0_nr = dir_inode->i_start_sect;
int nr_dir_blks = (dir_inode->i_size + SECTOR_SIZE - 1) / SECTOR_SIZE;
int nr_dir_entries =
dir_inode->i_size / DIR_ENTRY_SIZE; /**
* including unused slots
* (the file has been deleted
* but the slot is still there)
*/
int m = 0;
struct dir_entry * pde;
for (i = 0; i < nr_dir_blks; i++) {
RD_SECT(dir_inode->i_dev, dir_blk0_nr + i);
pde = (struct dir_entry *)fsbuf;
for (j = 0; j < SECTOR_SIZE / DIR_ENTRY_SIZE; j++,pde++) {
if (memcmp(filename, pde->name, MAX_FILENAME_LEN) == 0)
return pde->inode_nr;
if (++m > nr_dir_entries)
break;
}
if (m > nr_dir_entries) /* all entries have been iterated */
break;
}
/* file not found */
return 0;
}
void commandoptions::print_usage(std::string executable)
{
// print usage and program name
std::cerr << "Usage: " << strip_path(executable);
// gather and print flags
std::string shorts = "-"; // we sort the flags into short and long ones
std::string longs;
for (flag_iterator i = flag_table.begin(); i != flag_table.end(); ++i) {
if (i->short_name != '\0')
shorts += i->short_name;
else
longs += ' ' + optionalify("--" + i->long_name);
}
// insert -? (for help)
shorts += '?';
std::cerr << ' ' << optionalify(shorts) << longs;
// print options
for (option_iterator i = option_table.begin(); i != option_table.end(); ++i)
if (i->short_name != '\0')
std::cerr << ' ' << optionalify(std::string("-") + i->short_name + " " + i->arg_name);
else
std::cerr << ' ' << optionalify("--" + i->long_name + " " + i->arg_name);
// then print --usage so it doesn't clutter up the more interesting options
std::cerr << ' ' + optionalify("--usage");
// and finally print arguments
for (argument_iterator i = argument_table.begin(); i != argument_table.end(); ++i)
std::cerr << ' ' << requirify(i->name);
std::cerr << std::endl;
std::exit(1);
}
static DBusMessage *agent_request_input(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct agent_data *request = user_data;
DBusMessageIter iter, dict;
char *service, *str;
if (handle_message(message, request, agent_request_input) == false)
return NULL;
dbus_message_iter_init(message, &iter);
dbus_message_iter_get_basic(&iter, &str);
service = strip_path(str);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &dict);
__connmanctl_save_rl();
if (strcmp(request->interface, AGENT_INTERFACE) == 0)
fprintf(stdout, "Agent RequestInput %s\n", service);
else
fprintf(stdout, "VPN Agent RequestInput %s\n", service);
__connmanctl_dbus_print(&dict, " ", " = ", "\n");
fprintf(stdout, "\n");
parse_agent_request(request, &iter);
request->reply = dbus_message_new_method_return(message);
dbus_message_iter_init_append(request->reply, &request->iter);
dbus_message_iter_open_container(&request->iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
&request->dict);
request_input_next(request);
return NULL;
}
static BOOL do_unlink(MESSAGE *message){
int inode_index,flags,sector_index,sector_length;
const char *path;
char dir_name[MAX_FILENAME_LENGTH]={0};
char file_name[MAX_FILENAME_LENGTH]={0};
INODE inode;
flags=message->flags;
path=message->arg_pointer;
//分离父目录路径和文件名
if(!strip_path(path,dir_name,file_name)){
return FALSE;
}
//1.get inode_index,and remove the dir_entry
inode_index=search_file(dir_name,file_name,GET_FILE_TYPE(flags));
#ifdef DEBUG_FS
printl("inode_index=%d(in do_unlink)\n",inode_index);
#endif
if(inode_index<0){
set_error_index(FILE_NOT_EXIST);
return FALSE;
}
if(!remove_dir_entry(dir_name,inode_index)){
set_error_index(FILE_NOT_EXIST);
return FALSE;
}
//2.get file inode by inode_index
get_inode_by_index(inode_index,&inode);
//3.clear imap by inode_index
free_imap_bit(inode_index);
//4.clear smap inode
sector_index=inode.i_start_sector_index-get_data_block_first_index(super_block);
sector_length=inode.i_sectors_length;
/* printl("sector_index=%d sector_length=%d data_first_index=%d\n",inode.i_start_sector_index,sector_length,get_data_block_first_index(super_block)); */
free_smap_bit(sector_index,sector_length);
return TRUE;
}
//path:the full name of the file
//return:inode num of the file if success, otherwise zero
int search_file(char *path)
{
#ifdef DEBUG_rw
printl("search_file : path =%s|\n", path );
#endif
int i,j;
char filename[MAX_PATH_LEN];
memset(filename , 0, MAX_FILENAME_LEN);
struct inode *dir_inode;
if(strip_path(filename, path, &dir_inode)!=0)
return 0;
#ifdef DEBUG_rw
printl("search_file : filename =%s|\n", filename );
#endif
if(filename[0]== 0)//path '/'
return dir_inode->i_num;
//search the dir for the file
int dir_sects0_index = dir_inode->i_start_sect;
int nr_dir_sects = (dir_inode->i_size +SECTOR_SIZE -1)/SECTOR_SIZE;
int nr_dir_dentries = (dir_inode->i_size)/DIR_ENTRY_SIZE;
int m= 0;
struct dir_entry *pde;
for (i = 0; i < nr_dir_sects; ++i) { //里面有空的
RD_SECT(dir_inode->i_dev, dir_sects0_index +i);
pde = (struct dir_entry *)fsbuf;
for(j=0; j<SECTOR_SIZE/DIR_ENTRY_SIZE; j++ , pde++) {
if(memcmp(filename , pde->name, MAX_FILENAME_LEN) == 0)
return pde->inode_nr;
if(++m >nr_dir_dentries)
break;
}
if(m> nr_dir_dentries)
break;
}
return 0;
}
/**************************************************************
* do_stat
**************************************************************
@function:get the information of a pathname
The information we need for stat hided in the inode. So we just need to get the info of inode of pathname.
@input:
@return:0 if sucess
**************************************************************/
int hykdo_stat()
{
char filename[MAX_FILENAME_LEN];
char pathname[MAX_PATH_LEN];
int pathname_len = fs_msg.NAME_LEN;
int src = fs_msg.source;
// pathname = fs_msg.PATHNAME; /*no!!! you can not do this directly! For they are not in the same address space*/
phys_copy( (void *)va2la(TASK_FS, pathname),\
(void *)va2la(src, fs_msg.PATHNAME),\
fs_msg.NAME_LEN);
pathname[pathname_len] = 0;
int inode_nr_path = search_file(pathname);
if(inode_nr_path == INVALID_INODE) {
printl("[FS]:stat faild becase of invalid inode\n");
return -1;
}
struct inode *dir_inode;
if(strip_path(filename, pathname, &dir_inode)!=0) {
assert(0);
}
struct inode *file_inode=get_inode(dir_inode->i_dev, inode_nr_path);
struct stat s;
s.dev = file_inode->i_dev;
s.size = file_inode->i_size;
s.mode = file_inode->i_mode;
s.ino = file_inode->i_num;
s.rdev = is_special(file_inode->i_mode) ? file_inode->i_start_sect: NO_DEV;
put_inode(file_inode);
phys_copy( (void *)va2la(src, fs_msg.BUF),\
(void *)va2la(TASK_FS, &stat),\
sizeof(struct stat));
printl("fs_msg.buf.size:%x", ((struct stat *)va2la(src, fs_msg.BUF))->size);
return 0;
}
PRIVATE struct inode *creat_file(char *path, int flags)
{
char filename[MAX_PATH];
struct inode *dir_inode;
/* 准备好文件名和文件夹的 inode */
if (strip_path(filename, path, &dir_inode) != 0)
return 0;
/* 分配 inode */
int inode_nr = alloc_imap_bit(dir_inode->i_dev);
/* 分配 sector */
int free_sect_nr = alloc_smap_bit(dir_inode->i_dev, NR_DEFAULT_FILE_SECTS);
/* 在 inode array 中分配一个 inode */
struct inode *newino = new_inode(dir_inode->i_dev, inode_nr, free_sect_nr);
/* 新建一个目录项 */
new_dir_entry(dir_inode, newino->i_num, filename);
return newino;
}
// get the directory associated with the riff - free with delete[]
static char * riff_basename(Chunk_With_Children * envd)
{
RIF_Name_Chunk * rnc = 0;
List<Chunk *> chlst = envd->lookup_child("RIFFNAME");
if (chlst.size())
{
rnc = (RIF_Name_Chunk *)chlst.first_entry();
const char * rif_name = strip_path(rnc->rif_name);
char * basename = new char[strlen(rif_name)+1];
strcpy(basename,rif_name);
strip_file_extension(basename);
return basename;
}
const char * deflt = "empty";
char * basename = new char [strlen(deflt)+1];
strcpy(basename,deflt);
return basename;
}
bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
{
BSOCK *sd = jcr->store_bsock;
POOL_MEM attribs(PM_NAME),
attribsExBuf(PM_NAME);
char *attribsEx = NULL;
int attr_stream;
int comp_len;
bool status;
int hangup = get_hangup();
#ifdef FD_NO_SEND_TEST
return true;
#endif
Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
/** Find what data stream we will use, then encode the attributes */
if ((data_stream = select_data_stream(ff_pkt, me->compatible)) == STREAM_NONE) {
/* This should not happen */
Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
return false;
}
encode_stat(attribs.c_str(), &ff_pkt->statp, sizeof(ff_pkt->statp), ff_pkt->LinkFI, data_stream);
/** Now possibly extend the attributes */
if (IS_FT_OBJECT(ff_pkt->type)) {
attr_stream = STREAM_RESTORE_OBJECT;
} else {
attribsEx = attribsExBuf.c_str();
attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
}
Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs.c_str(), attribsEx);
jcr->lock();
jcr->JobFiles++; /* increment number of files sent */
ff_pkt->FileIndex = jcr->JobFiles; /* return FileIndex */
pm_strcpy(jcr->last_fname, ff_pkt->fname);
jcr->unlock();
/*
* Debug code: check if we must hangup
*/
if (hangup && (jcr->JobFiles > (uint32_t)hangup)) {
jcr->setJobStatus(JS_Incomplete);
Jmsg1(jcr, M_FATAL, 0, "Debug hangup requested after %d files.\n", hangup);
set_hangup(0);
return false;
}
/**
* Send Attributes header to Storage daemon
* <file-index> <stream> <info>
*/
if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
if (!jcr->is_canceled() && !jcr->is_incomplete()) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"), sd->bstrerror());
}
return false;
}
Dmsg1(300, ">stored: attrhdr %s", sd->msg);
/**
* Send file attributes to Storage daemon
* File_index
* File type
* Filename (full path)
* Encoded attributes
* Link name (if type==FT_LNK or FT_LNKSAVED)
* Encoded extended-attributes (for Win32)
* Delta Sequence Number
*
* or send Restore Object to Storage daemon
* File_index
* File_type
* Object_index
* Object_len (possibly compressed)
* Object_full_len (not compressed)
* Object_compression
* Plugin_name
* Object_name
* Binary Object data
*
* For a directory, link is the same as fname, but with trailing
* slash. For a linked file, link is the link.
*/
if (!IS_FT_OBJECT(ff_pkt->type) && ff_pkt->type != FT_DELETED) { /* already stripped */
strip_path(ff_pkt);
}
switch (ff_pkt->type) {
case FT_JUNCTION:
case FT_LNK:
case FT_LNKSAVED:
Dmsg3(300, "Link %d %s to %s\n", jcr->JobFiles, ff_pkt->fname, ff_pkt->link);
status = sd->fsend("%ld %d %s%c%s%c%s%c%s%c%u%c", jcr->JobFiles,
ff_pkt->type, ff_pkt->fname, 0, attribs.c_str(), 0,
ff_pkt->link, 0, attribsEx, 0, ff_pkt->delta_seq, 0);
break;
case FT_DIREND:
case FT_REPARSE:
/* Here link is the canonical filename (i.e. with trailing slash) */
status = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
ff_pkt->type, ff_pkt->link, 0, attribs.c_str(), 0, 0,
attribsEx, 0, ff_pkt->delta_seq, 0);
break;
case FT_PLUGIN_CONFIG:
case FT_RESTORE_FIRST:
comp_len = ff_pkt->object_len;
ff_pkt->object_compression = 0;
if (ff_pkt->object_len > 1000) {
/*
* Big object, compress it
*/
comp_len = compressBound(ff_pkt->object_len);
POOLMEM *comp_obj = get_memory(comp_len);
/*
* FIXME: check Zdeflate error
*/
Zdeflate(ff_pkt->object, ff_pkt->object_len, comp_obj, comp_len);
if (comp_len < ff_pkt->object_len) {
ff_pkt->object = comp_obj;
ff_pkt->object_compression = 1; /* zlib level 9 compression */
} else {
/*
* Uncompressed object smaller, use it
*/
comp_len = ff_pkt->object_len;
}
Dmsg2(100, "Object compressed from %d to %d bytes\n", ff_pkt->object_len, comp_len);
}
sd->msglen = Mmsg(sd->msg, "%d %d %d %d %d %d %s%c%s%c",
jcr->JobFiles, ff_pkt->type, ff_pkt->object_index,
comp_len, ff_pkt->object_len, ff_pkt->object_compression,
ff_pkt->fname, 0, ff_pkt->object_name, 0);
sd->msg = check_pool_memory_size(sd->msg, sd->msglen + comp_len + 2);
memcpy(sd->msg + sd->msglen, ff_pkt->object, comp_len);
/*
* Note we send one extra byte so Dir can store zero after object
*/
sd->msglen += comp_len + 1;
status = sd->send();
if (ff_pkt->object_compression) {
free_and_null_pool_memory(ff_pkt->object);
}
break;
case FT_REG:
status = sd->fsend("%ld %d %s%c%s%c%c%s%c%d%c", jcr->JobFiles,
ff_pkt->type, ff_pkt->fname, 0, attribs.c_str(), 0, 0,
attribsEx, 0, ff_pkt->delta_seq, 0);
break;
default:
status = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
ff_pkt->type, ff_pkt->fname, 0, attribs.c_str(), 0, 0,
attribsEx, 0, ff_pkt->delta_seq, 0);
break;
}
if (!IS_FT_OBJECT(ff_pkt->type) && ff_pkt->type != FT_DELETED) {
unstrip_path(ff_pkt);
}
Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
if (!status && !jcr->is_job_canceled()) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"), sd->bstrerror());
}
sd->signal(BNET_EOD); /* indicate end of attributes data */
return status;
}
bool PhotoGeocoder::geocoding_pipeline(string photoPath, GPSCoords &lla){
//--- Extract Exif data
//---------------------
cv::Mat K;
extract_k_matrix(photoPath, ccdData, K);
//--- Extract Features & Descriptors
//----------------------------------
vector<Feature> features;
vector<Descriptor> descriptors;
ftk->extract_features(photoPath,features,descriptors);
//--- VTree Match
//---------------
logger << INDENT << "Quering vocabulary tree for similar documents..." << "\n";
QueryResults listDocuments = vtree.query(descriptors, MAX_DOCUMENTS);
for(int i = 0; i < MAX_DOCUMENTS && i < (int) listDocuments.size(); i++){
logger << INDENT << "Loading document " << i << "\n";
vector<Descriptor> documentDescs;
vector<Point3D> points3D;
string pathDoc;
dbm.query_synth_path(listDocuments[i].Id, pathDoc);
//--- Load documents
//------------------
if(!load_synthetic(pathDoc, points3D, documentDescs))
return EXIT_FAILURE;
//--- Match photo<->documents
//---------------------------
logger << INDENT << "Matching with document... " << "\n";
vector<pair<int,int> > matches;
int nMatches = ftk->match_features(descriptors, documentDescs, matches);
logger << INDENT << nMatches << " sift matches were found" << "\n";
//--- If not enough matches
if(nMatches < M_LIMIT){
logger << INDENT << "not enough matches...skipping." << "\n";
continue;
}
vector<cv::Point2f> matchedPoints2D = vector<cv::Point2f>(nMatches);
vector<cv::Point3f> matchedPoints3D = vector<cv::Point3f>(nMatches);
for(int j = 0; j < nMatches; j++){
matchedPoints2D[j] = features[matches[j].first].pt;
matchedPoints3D[j] = points3D[matches[j].second];
}
//--- Compute Projection
//----------------------
cv::Matx34f P;
if(!find_proj_matrix(matchedPoints2D, matchedPoints3D,K,P)){
logger << INDENT << "Fail to compute P...skipping." << "\n";
continue;
}
cv::Matx44f G;
float error;
load_transformation_mat(strip_path(pathDoc) + "/../" + "transformMat.txt", error, G);
//--- Apply GPS transformation
//----------------------------
lla = apply_transformation(P, G);
//--- Compute Error
//-----------------
//TODO: this
//distance_gps(lla1,lla2);
logger << INDENT << photoPath << " --> geocoded at:" << "\n";
logger << INDENT << INDENT << "Latitude: " << lla.lat << "\n";
logger << INDENT << INDENT << "Longitude: " << lla.lon << "\n";
return true;
}
logger << INDENT << photoPath << " --> not geocoded" << "\n";
return false;
}
PUBLIC int do_open()
{
int i = 0;
int fd = -1; // return value
char pathname[MAX_PATH];
int flags = fs_msg.FLAGS;
int name_len = fs_msg.NAME_LEN;
int src = fs_msg.source;
assert(name_len < MAX_PATH);
phys_copy(
(void *)va2la(TASK_FS, pathname),
(void *)va2la(src, fs_msg.PATHNAME),
name_len
);
pathname[name_len] = 0;
/* 先在调用者进程中查找空闲文件描述符 */
for (i = 0; i < NR_FILES; i++)
if (pcaller->filp[i] == 0) {
fd = i;
break;
}
if ((fd < 0) || (fd >= NR_FILES))
panic("filp[] is full (PID:%d)", proc2pid(pcaller));
/* 然后在 f_desc_table 中查找空闲位置 */
for (i = 0; i < NR_FILE_DESC; i++)
if (f_desc_table[i].fd_inode == 0)
break;
if (i >= NR_FILE_DESC)
panic("f_desc_table[] is full (PID:%d)", proc2pid(pcaller));
/* 在磁盘中查找文件 */
int inode_nr = search_file(pathname);
/* 准备创建或打开文件 */
struct inode *pin = 0;
if (flags & O_CREAT) {
if (inode_nr) {
printl("file exists.\n");
return -1;
}
else { // 文件不存在且标志位 O_CREAT
pin = creat_file(pathname, flags);
}
}
else {
assert(flags & O_RDWR);
char filename[MAX_PATH];
struct inode * dir_inode;
if (strip_path(filename, pathname, &dir_inode) != 0)
return -1;
pin = get_inode(dir_inode->i_dev, inode_nr);
}
/* 关联文件描述符 */
if (pin) {
/* proc <- fd (connects proc with file_descriptor) */
pcaller->filp[fd] = &f_desc_table[i];
/* fd <- inode (connects file_descriptor with inode) */
f_desc_table[i].fd_mode = flags;
f_desc_table[i].fd_pos = 0;
f_desc_table[i].fd_inode = pin;
int imode = pin->i_mode & I_TYPE_MASK;
if (imode == I_CHAR_SPECIAL) {
MESSAGE driver_msg;
driver_msg.type = DEV_OPEN;
int dev = pin->i_start_sect;
driver_msg.DEVICE = MINOR(dev);
assert(MAJOR(dev) == 4);
assert(dd_map[MAJOR(dev)].driver_nr != INVALID_DRIVER);
/* 如果是字符设备则交给该设备的驱动处理 */
send_recv(BOTH, dd_map[MAJOR(dev)].driver_nr, &driver_msg);
}
else if (imode == I_DIRECTORY)
assert(pin->i_num == ROOT_INODE);
else
assert(pin->i_mode == I_REGULAR);
}
else
return -1; // open file failed
return fd;
}
/**
* Open a file and return the file descriptor.
*
* @return File descriptor if successful, otherwise a negative error code.
*****************************************************************************/
PUBLIC int do_open()
{
int fd = -1; /* return value */
char pathname[MAX_PATH];
/* get parameters from the message */
int flags = fs_msg.FLAGS; /* access mode */
int name_len = fs_msg.NAME_LEN; /* length of filename */
int src = fs_msg.source; /* caller proc nr. */
assert(name_len < MAX_PATH);
phys_copy((void*)va2la(TASK_FS, pathname),
(void*)va2la(src, fs_msg.PATHNAME),
name_len);
pathname[name_len] = 0;
/* find a free slot in PROCESS::filp[] */
int i;
for (i = 0; i < NR_FILES; i++) {
if (pcaller->filp[i] == 0) {
fd = i;
break;
}
}
if ((fd < 0) || (fd >= NR_FILES))
panic("filp[] is full (PID:%d)", proc2pid(pcaller));
/* find a free slot in f_desc_table[] */
for (i = 0; i < NR_FILE_DESC; i++)
if (f_desc_table[i].fd_inode == 0)
break;
if (i >= NR_FILE_DESC)
panic("f_desc_table[] is full (PID:%d)", proc2pid(pcaller));
int inode_nr = search_file(pathname);
struct inode * pin = 0;
if (flags & O_CREAT) {
if (inode_nr) {
printl("file exists.\n");
return -1;
}
else {
pin = create_file(pathname, flags);
}
}
else {
assert(flags & O_RDWR);
char filename[MAX_PATH];
struct inode * dir_inode;
if (strip_path(filename, pathname, &dir_inode) != 0)
return -1;
pin = get_inode(dir_inode->i_dev, inode_nr);
}
if (pin) {
/* connects proc with file_descriptor */
pcaller->filp[fd] = &f_desc_table[i];
/* connects file_descriptor with inode */
f_desc_table[i].fd_inode = pin;
f_desc_table[i].fd_mode = flags;
/* f_desc_table[i].fd_cnt = 1; */
f_desc_table[i].fd_pos = 0;
int imode = pin->i_mode & I_TYPE_MASK;
if (imode == I_CHAR_SPECIAL) {
MESSAGE driver_msg;
driver_msg.type = DEV_OPEN;
int dev = pin->i_start_sect;
driver_msg.DEVICE = MINOR(dev);
assert(MAJOR(dev) == 4);
assert(dd_map[MAJOR(dev)].driver_nr != INVALID_DRIVER);
send_recv(BOTH,
dd_map[MAJOR(dev)].driver_nr,
&driver_msg);
}
else if (imode == I_DIRECTORY) {
assert(pin->i_num == ROOT_INODE);
}
else {
assert(pin->i_mode == I_REGULAR);
}
}
else {
return -1;
}
return fd;
}
void SID_init(int *argc,
char **argv[],
SID_args args[],
void *mpi_comm_as_void){
int status;
int i_level;
int i_char;
int flag_continue;
int flag_passed_comm;
// MPI-specific things
#if USE_MPI
int n_keys;
int i_key;
char key[256];
char key_value[256];
int key_exists;
char nodes_string[256];
SID_fp fp_tmp;
FILE *fp_hack;
int node_name_length;
MPI_Comm mpi_comm;
#if USE_MPI_IO
MPI_Info info_disp;
#endif
if (mpi_comm_as_void == NULL)
{
flag_passed_comm = 0;
MPI_Init(argc,argv);
MPI_Comm_dup(MPI_COMM_WORLD, &mpi_comm);
}
else
{
mpi_comm = *((MPI_Comm *) mpi_comm_as_void);
flag_passed_comm = 1;
}
MPI_Comm_size(mpi_comm, &(SID.n_proc));
MPI_Comm_rank(mpi_comm, &(SID.My_rank));
SID.My_node =(char *)SID_malloc(SID_MAXLENGTH_PROCESSOR_NAME * sizeof(char));
#if USE_MPI
MPI_Get_processor_name(SID.My_node, &node_name_length);
#else
sprintf(SID.My_node,"localhost");
node_name_length=strlen(SID.My_node);
#endif
if (node_name_length >= SID_MAXLENGTH_PROCESSOR_NAME-1)
SID_trap_error("SID_MAXLENGTH_PROCESSOR_NAME needs to be increased",ERROR_LOGIC);
// Make my_rank=MASTER_RANK the master
if(SID.My_rank==MASTER_RANK)
SID.I_am_Master=TRUE;
else
SID.I_am_Master=FALSE;
// Identify the last rank
if(SID.My_rank==SID.n_proc-1)
SID.I_am_last_rank=TRUE;
else
SID.I_am_last_rank=FALSE;
#if USE_MPI_IO
// Fetch collective buffering defaults
MPI_Info_create(&(SID.file_info));
if(SID.I_am_Master){
fp_hack=fopen(".tmp.SID","w+");
fclose(fp_hack);
}
MPI_Barrier(mpi_comm);
MPI_File_open(mpi_comm,
".tmp.SID",
MPI_MODE_WRONLY,
MPI_INFO_NULL,
&(fp_tmp.fp));
MPI_File_get_info(fp_tmp.fp,&info_disp);
MPI_Info_get_nkeys(info_disp,&n_keys);
for(i_key=0;i_key<n_keys;i_key++){
MPI_Info_get_nthkey(info_disp,i_key,key);
MPI_Info_get(info_disp,key,MPI_MAX_INFO_VAL,key_value,&key_exists);
if(key_exists)
MPI_Info_set((SID.file_info),key,key_value);
}
MPI_File_close(&(fp_tmp.fp));
if(SID.I_am_Master)
remove(".tmp.SID");
// Set user-defined colective buffering optimizations
sprintf(nodes_string,"%d",MIN(SID.n_proc,N_IO_FILES_MAX));
MPI_Info_set((SID.file_info),"cb_nodes", nodes_string);
MPI_Info_set((SID.file_info),"cb_config_list", "*:1");
#endif
#else
SID.My_rank=MASTER_RANK;
SID.n_proc =1;
#endif
/*
#if !USE_MPI_IO
SID.n_groups=SID.n_proc/N_IO_FILES_MAX;
if(SID.n_proc%N_IO_FILES_MAX) SID.n_groups++;
SID.My_group=SID.My_rank/N_IO_FILES_MAX;
#endif
*/
// Set ranks to the left and right
SID.rank_to_right =(SID.My_rank+1)%SID.n_proc;
SID.rank_to_left = SID.My_rank-1;
if(SID.rank_to_left<0)
SID.rank_to_left = SID.n_proc-1;
// Intitialize log timing information
SID.time_start_level=(time_t *)SID_malloc(sizeof(time_t)*SID_LOG_MAX_LEVELS);
SID.time_stop_level =(time_t *)SID_malloc(sizeof(time_t)*SID_LOG_MAX_LEVELS);
SID.time_total_level=(int *)SID_malloc(sizeof(int) *SID_LOG_MAX_LEVELS);
SID.IO_size =(double *)SID_malloc(sizeof(double)*SID_LOG_MAX_LEVELS);
SID.flag_use_timer =(int *)SID_malloc(sizeof(int) *SID_LOG_MAX_LEVELS);
for(i_level=0;i_level<SID_LOG_MAX_LEVELS;i_level++){
SID.time_start_level[i_level]=0;
SID.time_stop_level[i_level] =0;
SID.time_total_level[i_level]=0;
SID.IO_size[i_level] =0.;
SID.flag_use_timer[i_level] =FALSE;
}
// Initialize other log information
#if USE_MPI
if(*argc>1)
SID.fp_in =fopen((*argv)[1],"r");
else
SID.fp_in =NULL;
#else
SID.fp_in =stdin;
#endif
if (flag_passed_comm)
SID.fp_log = NULL;
else
SID.fp_log = stderr;
SID.level =0;
SID.indent =TRUE;
SID.awake =TRUE;
SID.flag_results_on=FALSE;
SID.verbosity =SID_LOG_MAX_LEVELS;
// Store the name of the binary executable that brought us here
strcpy(SID.My_binary,(*argv)[0]);
strip_path(SID.My_binary);
// Initialize argument information
if(args!=NULL){
if((status=SID_parse_args(*argc,*argv,args))>0){
SID_print_syntax(*argc,*argv,args);
SID_exit(status);
}
}
else
SID.args=NULL;
#if USE_MPI_IO
if(SID.I_am_Master){
fp_hack=fopen(".tmp.SID","w+");
fclose(fp_hack);
}
MPI_Barrier(mpi_comm);
SID_fopen(".tmp.SID","w",&fp_tmp);
MPI_File_get_info(fp_tmp.fp,&info_disp);
if(SID.I_am_Master){
fprintf(stdout,"\n");
fprintf(stdout,"MPI-I/O Configuration:\n");
fprintf(stdout,"---------------------\n");
MPI_Info_get_nkeys(info_disp,&n_keys);
for(i_key=0;i_key<n_keys;i_key++){
MPI_Info_get_nthkey(info_disp,i_key,key);
MPI_Info_get(info_disp,key,MPI_MAX_INFO_VAL,key_value,&key_exists);
if(key_exists)
fprintf(stdout,"key %2d of %d: {%s}={%s}\n",i_key+1,n_keys,key,key_value);
}
fprintf(stdout,"\n");
}
SID_fclose(&fp_tmp);
if(SID.I_am_Master)
remove(".tmp.SID");
#else
#if USE_MPI
if(SID.I_am_Master)
fprintf(stdout,"MPI-I/O switched off.\n\n");
#endif
#endif
// Create private COMM_WORLD
SID_Comm_init(&(SID.COMM_WORLD));
#if USE_MPI
MPI_Comm_dup(mpi_comm, &((SID.COMM_WORLD)->comm));
MPI_Comm_group((SID.COMM_WORLD)->comm,&((SID.COMM_WORLD)->group));
MPI_Comm_size(SID.COMM_WORLD->comm, &((SID.COMM_WORLD)->n_proc));
MPI_Comm_rank(SID.COMM_WORLD->comm, &((SID.COMM_WORLD)->My_rank));
// We have duplicated our duplicate mpi communicator - now we can free the
// original duplicate
MPI_Comm_free(&mpi_comm);
#else
SID.COMM_WORLD->comm =NULL;
SID.COMM_WORLD->group =NULL;
SID.COMM_WORLD->n_proc =1;
SID.COMM_WORLD->My_rank=MASTER_RANK;
#endif
// Start total-run-ime timer
(void)time(&(SID.time_start));
// Default max wallclock
SID.max_wallclock=DEFAULT_MAX_WALLCLOCK_TIME;
}
int main(int argc, char *argv[]){
int n_search;
int i_halo;
char filename_SSimPL_root[MAX_FILENAME_LENGTH];
char filename_in[MAX_FILENAME_LENGTH];
char group_text_prefix[4];
int n_files;
int k_read;
int max_n_groups;
int l_read;
int n_groups;
int j_read;
int mode;
int n_groups_i;
int n_groups_j;
int j_halo;
int match;
int i_read;
int i_read_start;
int i_read_stop;
SID_fp fp_in;
SID_init(&argc,&argv,NULL,NULL);
// Fetch user inputs
strcpy(filename_SSimPL_root,argv[1]);
if(!strcmp(argv[2],"groups") || !strcmp(argv[2],"group"))
mode=MATCH_GROUPS;
else if(!strcmp(argv[2],"subgroups") || !strcmp(argv[2],"subgroup"))
mode=MATCH_SUBGROUPS;
else{
SID_log("Invalid mode selection {%s}. Should be 'group' or 'subgroup'.",SID_LOG_COMMENT,argv[2]);
SID_exit(ERROR_SYNTAX);
}
i_read=atoi(argv[3]);
j_read=atoi(argv[4]);
SID_log("Searching match information for halo #%d in file #%d of {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,i_halo,i_read,filename_SSimPL_root);
// Convert filename_root to filename
switch(mode){
case MATCH_SUBGROUPS:
sprintf(group_text_prefix,"sub");
break;
case MATCH_GROUPS:
sprintf(group_text_prefix,"");
break;
}
// Set the standard SSiMPL match file path
char filename_root_in[MAX_FILENAME_LENGTH];
sprintf(filename_root_in,"%s/trees/matches/",filename_SSimPL_root);
// Set the output file
char filename_base[MAX_FILENAME_LENGTH];
char filename_out[MAX_FILENAME_LENGTH];
sprintf(filename_base,filename_SSimPL_root);
if(!strcmp(&(filename_base[strlen(filename_base)-1]),"/"))
strcpy(&(filename_base[strlen(filename_base)-1]),"\0");
strip_path(filename_base);
sprintf(filename_out,"%s_%d_%d_2way_matches.txt",filename_base,i_read,j_read);
// Read header information
SID_log("Reading header information...",SID_LOG_OPEN);
sprintf(filename_in,"%s/%sgroup_matches_header.dat",filename_root_in,group_text_prefix);
SID_fopen(filename_in,"r",&fp_in);
SID_fread(&i_read_start,sizeof(int),1,&fp_in);SID_log("snap start =%d",SID_LOG_COMMENT,i_read_start);
SID_fread(&i_read_stop, sizeof(int),1,&fp_in);SID_log("snap stop =%d",SID_LOG_COMMENT,i_read_stop);
SID_fread(&n_search, sizeof(int),1,&fp_in);SID_log("search range=%d",SID_LOG_COMMENT,n_search);
SID_fread(&n_files, sizeof(int),1,&fp_in);SID_log("# of files =%d",SID_LOG_COMMENT,n_files);
for(k_read=0,max_n_groups=0;k_read<n_files;k_read++){
SID_fread(&l_read, sizeof(int),1,&fp_in);
SID_fread(&n_groups,sizeof(int),1,&fp_in);
SID_fseek(&fp_in, sizeof(int),n_groups,SID_SEEK_CUR);
if(mode==MATCH_GROUPS)
SID_fseek(&fp_in, sizeof(int),n_groups,SID_SEEK_CUR);
max_n_groups=MAX(max_n_groups,n_groups);
}
SID_log("Max # groups=%d",SID_LOG_COMMENT,max_n_groups);
SID_fclose(&fp_in);
SID_log("Done.",SID_LOG_CLOSE);
// Initialize some arrays
int *n_particles_i =(int *)SID_malloc(sizeof(int) *max_n_groups);
int *n_particles_j =(int *)SID_malloc(sizeof(int) *max_n_groups);
int *match_forward_ids =(int *)SID_malloc(sizeof(int) *max_n_groups);
size_t *match_forward_index =(size_t *)SID_malloc(sizeof(size_t)*max_n_groups);
float *match_forward_score =(float *)SID_malloc(sizeof(float) *max_n_groups);
char *match_forward_2way =(char *)SID_malloc(sizeof(char) *max_n_groups);
int *match_backward_ids =(int *)SID_malloc(sizeof(int) *max_n_groups);
size_t *match_backward_index=(size_t *)SID_malloc(sizeof(size_t)*max_n_groups);
float *match_backward_score=(float *)SID_malloc(sizeof(float) *max_n_groups);
char *match_backward_2way =(char *)SID_malloc(sizeof(char) *max_n_groups);
// Loop over all matching combinations
SID_log("Reading forward matches...",SID_LOG_OPEN|SID_LOG_TIMER);
SID_set_verbosity(SID_SET_VERBOSITY_DEFAULT);
read_matches(filename_root_in,
i_read,
j_read,
max_n_groups,
mode,
&n_groups_i,
&n_groups_j,
n_particles_i,
n_particles_j,
NULL,
NULL,
match_forward_ids,
match_forward_score,
match_forward_index,
match_forward_2way,
FALSE);
SID_log("Done.",SID_LOG_CLOSE);
SID_log("Processing backwards matches...",SID_LOG_OPEN|SID_LOG_TIMER);
read_matches(filename_root_in,
j_read,
i_read,
max_n_groups,
mode,
&n_groups_j,
&n_groups_i,
n_particles_j,
n_particles_i,
NULL,
NULL,
match_backward_ids,
match_backward_score,
match_backward_index,
match_backward_2way,
FALSE);
SID_log("Done.",SID_LOG_CLOSE);
// Open output file
FILE *fp_out;
fp_out=fopen(filename_out,"w");
int i_column=1;
fprintf(fp_out,"# Column (%02d): Halo index for snapshot %d\n", i_column++,i_read);
fprintf(fp_out,"# (%02d): Halo index for snapshot %d\n", i_column++,j_read);
fprintf(fp_out,"# (%02d): No. particles in snapshot %d\n", i_column++,i_read);
fprintf(fp_out,"# (%02d): No. particles in snapshot %d\n", i_column++,j_read);
fprintf(fp_out,"# (%02d): Forward match score\n", i_column++);
fprintf(fp_out,"# (%02d): Forward match score/min match score\n",i_column++);
fprintf(fp_out,"# (%02d): Backward match score\n", i_column++);
fprintf(fp_out,"# (%02d): Backward match score/min match score\n",i_column++);
for(int i_halo=0;i_halo<n_groups_i;i_halo++){
int j_halo=match_forward_ids[i_halo];
if(match_forward_2way[i_halo]){
if(j_halo<0 || j_halo>n_groups_j)
SID_trap_error("There's an invalid match id (ie. %d<0 || %d>%d) attached to a 2-way match!",ERROR_LOGIC,j_halo,j_halo,n_groups_j);
fprintf(fp_out,"%7d %7d %6d %6d %10.3le %10.3le %10.3le %10.3le\n",
i_halo,
j_halo,
n_particles_i[i_halo],
n_particles_j[j_halo],
match_forward_score[i_halo],
match_forward_score[i_halo]/minimum_match_score((double)n_particles_i[i_halo]),
match_backward_score[j_halo],
match_backward_score[j_halo]/minimum_match_score((double)n_particles_j[j_halo]));
}
}
fclose(fp_out);
// Clean-up
SID_free(SID_FARG n_particles_i);
SID_free(SID_FARG n_particles_j);
SID_free(SID_FARG match_forward_ids);
SID_free(SID_FARG match_forward_index);
SID_free(SID_FARG match_forward_score);
SID_free(SID_FARG match_forward_2way);
SID_free(SID_FARG match_backward_ids);
SID_free(SID_FARG match_backward_index);
SID_free(SID_FARG match_backward_score);
SID_free(SID_FARG match_backward_2way);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
void CL_RIFFImage::GetPath(ImageDescriptor const & idsc, Environment_Data_Chunk * envd, BMPN_Flags bflags)
{
if (fname) delete[] fname;
fname = 0;
// set the name
if (name) delete[] name;
char * nptr = strip_path(idsc.filename);
name = new char[strlen(nptr)+1];
strcpy(name,nptr);
#if 0
char orig_ext[32];
char const * oeP = strrchr(name,'.');
if (!oeP) eoP = "";
strcpy(orig_ext,oeP);
#endif
strip_file_extension(name);
// load this image
char const * pg0ext = ".PG0";
switch (imode)
{
case CLM_16BIT:
case CLM_24BIT:
case CLM_32BIT:
#if ALLOW_LOAD_ORIGINAL
{
char const * dir2 = idsc.flags & IDSCF_SPRITE ? "Sprites\\" : "";
char * riffname = riff_basename(envd);
char const * dir3 = idsc.flags & IDSCF_INCLUDED ? idsc.rifname : riffname;
fname = new char[strlen(ToolsTex_Directory)+strlen(dir2)+strlen(dir3)+1+strlen(name)+5];
strcpy(fname,ToolsTex_Directory);
strcat(fname,dir2);
strcat(fname,dir3);
strcat(fname,"\\");
strcat(fname,name);
strcat(fname,".PP0");
delete[] riffname;
break;
}
#endif
case CLM_ATTACHEDPALETTE:
{
char const * dir2 = idsc.flags & IDSCF_SPRITE ? "Sprites\\" : idsc.flags & IDSCF_SUBSHAPE ? "SubShps\\All\\" : "";
char * riffname = riff_basename(envd);
char const * dir3 = idsc.flags & IDSCF_INCLUDED ? idsc.rifname : riffname;
fname = new char[strlen(GenTex_Directory)+strlen(dir2)+strlen(dir3)+1+strlen(name)+5];
strcpy(fname,GenTex_Directory);
strcat(fname,dir2);
strcat(fname,dir3);
strcat(fname,"\\");
strcat(fname,name);
strcat(fname,".BM0");
delete[] riffname;
#if TRY_OLD_DIRS // temporary until all textures go into subshps directory
FFILE * ftest = ffopen(fname,"rb");
if (ftest) ffclose(ftest);
else
{
_LOGPUT("WARNING! Not found in SubShps directory\n");
char const * dir2 = idsc.flags & IDSCF_SPRITE ? "Sprites\\" : "";
char * riffname = riff_basename(envd);
char const * dir3 = idsc.flags & IDSCF_INCLUDED ? idsc.rifname : riffname;
delete[] fname;
fname = new char[strlen(GenTex_Directory)+strlen(dir2)+strlen(dir3)+1+strlen(name)+5];
strcpy(fname,GenTex_Directory);
strcat(fname,dir2);
strcat(fname,dir3);
strcat(fname,"\\");
strcat(fname,name);
strcat(fname,".BM0");
delete[] riffname;
}
#endif
break;
}
case CLM_TLTPALETTE:
if (!(bflags & ChunkBMPFlag_NotLit))
{
pg0ext = ".PW0";
flags.tltpalette = 1;
}
case CLM_GLOBALPALETTE:
{
if (idsc.flags & IDSCF_FIXEDPALETTE)
{
char const * dir2 = idsc.fixrifname ? *idsc.fixrifname ? idsc.fixrifname : 0 : 0;
char const * dir3 = idsc.flags & IDSCF_SPRITE ? "Sprites\\" : "";
char * riffname = riff_basename(envd);
char const * dir4 = idsc.flags & IDSCF_INCLUDED ? idsc.rifname : riffname;
fname = new char[strlen(FixTex_Directory)+(dir2 ? strlen(dir2)+1 : 0)+strlen(dir3)+strlen(dir4)+1+strlen(name)+5];
strcpy(fname,FixTex_Directory);
if (dir2)
{
strcat(fname,dir2);
strcat(fname,"\\");
}
strcat(fname,dir3);
strcat(fname,dir4);
strcat(fname,"\\");
strcat(fname,name);
strcat(fname,pg0ext);
delete[] riffname;
}
else
{
char const * dir1 = game_mode ? GameTex_Directory : ToolsTex_Directory;
char * dir2 = riff_basename(envd);
char const * dir4 = idsc.flags & IDSCF_SPRITE ? "Sprites\\" : "";
char const * dir5 = idsc.flags & IDSCF_INCLUDED ? idsc.rifname : 0;
fname = new char[strlen(dir1)+strlen(dir2)+1+(game_mode ? strlen(game_mode)+1 : 0)+strlen(dir4)+(dir5 ? strlen(dir5)+1 : 0)+strlen(name)+5];
strcpy(fname,dir1);
strcat(fname,dir2);
strcat(fname,"\\");
if (game_mode)
{
strcat(fname,game_mode);
strcat(fname,"\\");
}
strcat(fname,dir4);
if (dir5)
{
strcat(fname,dir5);
strcat(fname,"\\");
}
strcat(fname,name);
strcat(fname,pg0ext);
delete[] dir2;
}
break;
}
}
if (!fname)
{
_LOGPUT("WARNING! GetPath returning NULL pointer\n");
}
else
_LOGPRINT(("file expected to be %s\n",fname));
}
