//*******************************去掉重复语料库********************************************************
//*******************************初步各选出200条数据作为实验***************后面做了手动修改****************************************************
void corpus_select(string filename_path, string path_read, string path_write)
{
string file_name; //存放每个文件的文件名
ifstream read_filename(filename_path); //从文件(LIST.TXT)读取各个文件名
string path_in, path_out, str_line; //path_in:读入文件的文件完整路径 path_out:写入文件的文件完整路径 str_line:存放读取的每行字符串
int number = 0;
while (getline(read_filename, file_name)) //读取各个文件名
{
number++;
cout << number << endl;
path_in = path_read + file_name;
path_out = path_write + file_name;
ifstream infile(path_in); //单个文件读取
ofstream outfile(path_out); //单个文件写入
int line = 0; //记录行号
while (getline(infile, str_line)) //读取每行字符串
{
line++;
if (line <= 800)continue;
else if (line>800&&line<=2000)
outfile << str_line << endl;
else break;
}
infile.close();
outfile.close();
}
read_filename.close();
}
//************************************************提取标题和内容并整合*******************************************************
void corpus_merge(string filename_path, string path_read, string path_write)
{
string file_name;
ifstream read_filename(filename_path);
ofstream outfile_category(path_write + "类别分离.txt");
ofstream outfile_title(path_write + "标题分离.txt");
ofstream outfile_content(path_write + "内容分离.txt");
string path_in;
string::size_type pos1, pos2, pos3, pos4;
string str_line;
while (getline(read_filename, file_name))
{
path_in = path_read + file_name;
ifstream infile(path_in);
while (getline(infile, str_line))
{
pos1 = 0; //pos1位置为0
pos2 = str_line.find("####"); //pos2位置为####字符串首字母所在位置 领用string.find(string) 函数寻找字符串位置
pos3 = str_line.find("****");
pos4 = str_line.find("&&&&");
outfile_category << str_line.substr(pos1, pos2 - pos1) << endl; //输出类别
outfile_title << str_line.substr(pos2 + 4, pos3 - pos2 - 4) << endl; //输出标题
outfile_content << str_line.substr(pos3 + 4, pos4 - pos3 - 4) << endl; //输出内容
}
infile.close();
}
}
/*Func: read_header()
* This function will read the header of a file put it in the correct format
*/
void read_header(int argc, char **argv, int *filecount, int opt, int *fcalled,file *info ){
read_filename(argv, filecount,opt,fcalled, info);
info->desc = open_file(info->name,0);
read_from_stat(info);
return ;
}
/*Func: opt_x()
* lseek 8 bytes from the beginning of arc
* read the file name from argv and ready to search
* find the file name from CLA
* read each header file and store it in info strct
* create a file by using open(info->name,RDWR_0|CREATE_O,0666)
* set header of a new file
* copy and paste the rest of the content from arch (use info->size)
*/
void opt_x(int argc, char **argv,int arch, int *filecount, int *fcalled, file *info){
char cur_name[16];
char *null_cur_name;
char *null_info_name;
int newfile=0;
int fbyte_max=120;
int fbyte=0;
struct stat archinfo;
fstat(arch,&archinfo);
fbyte_max = archinfo.st_size;
for((*fcalled) = 0; (*fcalled)<filecount[3];++(*fcalled)){
fbyte = 0;
lseek(arch,8,SEEK_SET);
read_filename(argv,filecount,2,fcalled,info);//get name from CLA
for(fbyte_max ; fbyte < fbyte_max; fbyte++ ){
//for the end of file
read(arch, cur_name,16); //get name of the file from arch
null_cur_name = null_str(cur_name,16);//turn both of the name into
null_cur_name = shrt_str(null_cur_name);
null_info_name = null_str(info->name,16);//null terminated strings
null_info_name = shrt_str(null_info_name);
if(!strcmp(null_cur_name, null_info_name)){
put_header(arch, info);
remove(null_info_name);
newfile = open(null_info_name, O_RDWR|O_CREAT,0666);
info->desc = arch;
lseek(arch,2,SEEK_CUR);
write_file_content(newfile, info);
if(atoi(info->size)%2!=0)
lseek(arch,1,SEEK_CUR);
utime(null_info_name, atoi(info->time));
chmod(null_info_name, strtol(info->mode,NULL,8));
break;
}else{
iter_arch(arch,&fbyte,info);
}
}//where the for EOF ends
if(fbyte>=fbyte_max)
printf(CY"Warning: File(\"%s\") doesn't documented in archeive.\nThe other file has successfully extract\n"NC,null_info_name);
}
/* printf("info->name: %.16s\n",info->name);
printf("info->time: %.12s\n",info->time);
printf("info->uid: %.6s\n",info->uid);
printf("info->gid: %.6s\n",info->gid);
printf("info->mode: %.8s\n",info->mode);
printf("info->size: %.10s\n",info->size);
*/
return;
}
//*****************抽取原始语料库中实验所需的行第2行中的类别，第4行中的标题，第5行中的内容******************************************************
void corpus_extract(string filename_path, string path_read, string path_write) //参数1：文件名列表路径 参数2：读取文件的目录 参数3：写入文件的目录
{
string file_name; //文件名
ifstream read_filename(filename_path); //从文件(LIST.TXT)读取各个文件名
int number = 0;
while (getline(read_filename, file_name)) //读取每一行的文件名
{
number++;
cout << number << endl;
string path_in = path_read + file_name; //单个文件的完整读取路径
string path_out = path_write + file_name; //单个文件的完整写入路径
ifstream infile(path_in); //单个文件读取
ofstream outfile(path_out); //单个文件写入
string str_line; //存放读取的一行类容
string str_result; //存放每行截取的字符串
int line_num = 0;
string::size_type pos1, pos2; //定义字符串的位置
while (getline(infile, str_line)) //读取每一行文件内容并放在str_line字符串中
{
line_num++;
if (line_num % 6 == 2) //读到第2行，输出类别
{
pos1 = str_line.find("//");
pos2 = str_line.find(".sohu");
str_result = str_line.substr(pos1 + 2, pos2 - pos1 - 2); //截取两个字符串位置中间的字符串类容并存放在str_result中
outfile << str_result << "####";
}
else if (line_num % 6 == 4) //读到第4行，输出标题
{
pos1 = str_line.find('>');
pos2 = str_line.find("</");
str_result = str_line.substr(pos1 + 1, pos2 - pos1 - 1);
outfile << str_result << "****";
}
else if (line_num % 6 == 5) //读到第5行，输出内容
{
pos1 = str_line.find('>');
pos2 = str_line.find("</");
str_result = str_line.substr(pos1 + 1, pos2 - pos1 - 1);
outfile << str_result << "&&&&";
}
else if (line_num % 6 == 0) //读到第6行输出换行符
{
outfile << endl;
}
else
continue;
}
infile.close();
outfile.close();
}
}
static bool recv_file(int recvfd)
{
bool rv = false;
char *filename = read_filename(recvfd);
if (!filename) return false;
fprintf(stderr, "recv'd filename: \"%s\"\n", filename);
uint32_t size;
if (!read_filesize(recvfd, &size)) goto fail_free;
rv = read_into_file(recvfd, size, filename);
fail_free:
free(filename);
char ack = (rv) ? 1 : 0;
return send_bytes(recvfd, &ack, 1) && rv;
}
void
rcv_file_mkdir (struct htlc_conn *htlc)
{
u_int16_t fnlen = 0;
char dir[MAXPATHLEN], filename[NAME_MAX], newbuf[MAXPATHLEN];
int err;
dir[0] = 0;
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_DIR:
err = hldir_to_path(dh, ROOTDIR, dir, dir);
if (err && err != ENOENT) {
snd_strerror(htlc, err);
return;
}
break;
}
dh_end()
if (!fnlen && !dir[0]) {
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
if (dir[0]) {
if (fnlen)
snprintf(newbuf, sizeof(newbuf), "%s/%s", dir, filename);
else
strcpy(newbuf, dir);
} else {
snprintf(newbuf, sizeof(newbuf), "%s/%s", ROOTDIR, filename);
}
if (check_dropbox(htlc, newbuf)) {
snd_strerror(htlc, EPERM);
return;
}
if (log_mkdir)
hxd_log("%s:%s:%u - mkdir %s", htlc->name, htlc->login, htlc->uid, newbuf);
if (SYS_mkdir(newbuf, hxd_cfg.permissions.directories))
snd_strerror(htlc, errno);
else
hlwrite(htlc, HTLS_HDR_TASK, 0, 0);
}
/*Func: read_header()
* This function will read the header of a file put it in the correct format
*/
void read_header(int argc, char **argv, int *filecount, int opt, int *fcalled,file *info ){
//FIXME: need to add opt var for the read_header func
read_filename(argv, filecount,opt,fcalled, info);
info->desc = open_file(info->name,0);
read_from_stat(info);
/* printf("info->time: %.12s\n", info->time);
printf("info->uid: %.6s\n", info->uid);
printf("info->gid: %.6s\n", info->gid);
printf("info->mode: %.8s\n", info->mode);
printf("info->size: %.10s\n", info->size);
*/
return ;
}
static int err_on_operation(int fd, const char* opname, size_t offset) {
char filename[FILENAME_BUFSIZE] = {0};
char always_eio_trigger[COMMAND_BUFSIZE] = {0};
char far_eio_trigger[COMMAND_BUFSIZE] = {0};
read_filename(fd, filename, FILENAME_BUFSIZE);
if (!strstr(filename, FILENAME_TRIGGER)) {
return 0;
}
// prepare substrings of the filename which trigger errors in various scenarios
sprintf(always_eio_trigger, "%s_EIO", opname);
sprintf(far_eio_trigger, "%s_far_EIO", opname);
if (strstr(filename, always_eio_trigger)) {
return EIO;
} else if (strstr(filename, far_eio_trigger) && offset > FAR_OFFSET_THRESHOLD) {
return EIO;
} else {
return 0;
}
}
static struct output *
get_openfile (struct output **file_ptrs, const char *mode, int fail)
{
struct buffer *b;
char *file_name;
struct output *p;
b = read_filename();
file_name = get_buffer(b);
for (p=*file_ptrs; p; p=p->link)
if (strcmp(p->name, file_name) == 0)
break;
if (posixicity == POSIXLY_EXTENDED)
{
/* Check whether it is a special file (stdin, stdout or stderr) */
struct special_files *special = special_files;
/* std* sometimes are not constants, so they
cannot be used in the initializer for special_files */
my_stdin = stdin; my_stdout = stdout; my_stderr = stderr;
for (special = special_files; special->outf.name; special++)
if (strcmp(special->outf.name, file_name) == 0)
{
special->outf.fp = *special->pfp;
free_buffer (b);
return &special->outf;
}
}
if (!p)
{
p = OB_MALLOC(&obs, 1, struct output);
p->name = ck_strdup(file_name);
p->fp = ck_fopen(p->name, mode, fail);
p->missing_newline = false;
p->link = *file_ptrs;
*file_ptrs = p;
}
//*********************************************筛选出各类别文件中 200<字符串数<800 的字符串*******************************************************
void corpus_filter(string filename_path, string path_read, string path_write)
{
string file_name; //存放每个文件的文件名
ifstream read_filename(filename_path); //从文件(LIST.TXT)读取各个文件名
string path_in, path_out, str_line; //path_in:读入文件的文件完整路径 path_out:写入文件的文件完整路径 str_line:存放读取的每行字符串
int number = 0;
while (getline(read_filename, file_name)) //读取各个文件名
{
number++;
cout << number << endl;
path_in = path_read + file_name;
path_out = path_write + file_name;
ifstream infile(path_in); //单个文件读取
ofstream outfile(path_out); //单个文件写入
while (getline(infile, str_line)) //读取每行字符串
{
if (str_line.length()>200 && str_line.length()<800) //选取字符串长度 200<长度<800 的字符串
outfile << str_line << endl;
}
infile.close(); //要关闭每次打开的文件流，因为有新的文件流产生。
outfile.close();
}
read_filename.close();
}
bool
db_dwarf_line_at_pc(const char *linetab, size_t linetabsize, uintptr_t pc,
const char **outdirname, const char **outbasename, int *outline)
{
struct dwbuf table = { .buf = linetab, .len = linetabsize };
/*
* For simplicity, we simply brute force search through the entire
* line table each time.
*/
uint32_t unitsize;
struct dwbuf unit;
next:
/* Line tables are a sequence of compilation unit entries. */
if (!read_u32(&table, &unitsize) || unitsize >= 0xfffffff0 ||
!read_buf(&table, &unit, unitsize))
return (false);
uint16_t version;
uint32_t header_size;
if (!read_u16(&unit, &version) || version > 2 ||
!read_u32(&unit, &header_size))
goto next;
struct dwbuf headerstart = unit;
uint8_t min_insn_length, default_is_stmt, line_range, opcode_base;
int8_t line_base;
if (!read_u8(&unit, &min_insn_length) ||
!read_u8(&unit, &default_is_stmt) ||
!read_s8(&unit, &line_base) ||
!read_u8(&unit, &line_range) ||
!read_u8(&unit, &opcode_base))
goto next;
/*
* Directory and file names are next in the header, but for now we
* skip directly to the line number program.
*/
struct dwbuf names = unit;
unit = headerstart;
if (!skip_bytes(&unit, header_size))
return (false);
/* VM registers. */
uint64_t address = 0, file = 1, line = 1, column = 0;
uint8_t is_stmt = default_is_stmt;
bool basic_block = false, end_sequence = false;
bool prologue_end = false, epilogue_begin = false;
/* Last line table entry emitted, if any. */
bool have_last = false;
uint64_t last_line = 0, last_file = 0;
/* Time to run the line program. */
uint8_t opcode;
while (read_u8(&unit, &opcode)) {
bool emit = false, reset_basic_block = false;
if (opcode >= opcode_base) {
/* "Special" opcodes. */
uint8_t diff = opcode - opcode_base;
address += diff / line_range;
line += line_base + diff % line_range;
emit = true;
} else if (opcode == 0) {
/* "Extended" opcodes. */
uint64_t extsize;
struct dwbuf extra;
if (!read_uleb128(&unit, &extsize) ||
!read_buf(&unit, &extra, extsize) ||
!read_u8(&extra, &opcode))
goto next;
switch (opcode) {
case DW_LNE_end_sequence:
emit = true;
end_sequence = true;
break;
case DW_LNE_set_address:
switch (extra.len) {
case 4: {
uint32_t address32;
if (!read_u32(&extra, &address32))
goto next;
address = address32;
break;
}
case 8:
if (!read_u64(&extra, &address))
goto next;
break;
default:
DWARN("unexpected address length: %zu",
extra.len);
goto next;
}
break;
case DW_LNE_define_file:
/* XXX: hope this isn't needed */
default:
DWARN("unknown extended opcode: %d", opcode);
goto next;
}
} else {
/* "Standard" opcodes. */
switch (opcode) {
case DW_LNS_copy:
emit = true;
reset_basic_block = true;
break;
case DW_LNS_advance_pc: {
uint64_t delta;
if (!read_uleb128(&unit, &delta))
goto next;
address += delta * min_insn_length;
break;
}
case DW_LNS_advance_line: {
int64_t delta;
if (!read_sleb128(&unit, &delta))
goto next;
line += delta;
break;
}
case DW_LNS_set_file:
if (!read_uleb128(&unit, &file))
goto next;
break;
case DW_LNS_set_column:
if (!read_uleb128(&unit, &column))
goto next;
break;
case DW_LNS_negate_stmt:
is_stmt = !is_stmt;
break;
case DW_LNS_set_basic_block:
basic_block = true;
break;
case DW_LNS_const_add_pc:
address += (255 - opcode_base) / line_range;
break;
case DW_LNS_set_prologue_end:
prologue_end = true;
break;
case DW_LNS_set_epilogue_begin:
epilogue_begin = true;
break;
default:
DWARN("unknown standard opcode: %d", opcode);
goto next;
}
}
if (emit) {
if (address > pc) {
/* Found an entry after our target PC. */
if (!have_last) {
/* Give up on this program. */
break;
}
/* Return the last entry. */
*outline = last_line;
return (read_filename(&names, outdirname,
outbasename, opcode_base, file));
}
last_file = file;
last_line = line;
have_last = true;
}
if (reset_basic_block)
basic_block = false;
}
goto next;
}
void
rcv_file_delete (struct htlc_conn *htlc)
{
u_int16_t fnlen = 0;
char dir[MAXPATHLEN], filename[NAME_MAX], oldbuf[MAXPATHLEN];
char rsrcpath_old[MAXPATHLEN];
struct stat sb, rsb;
int err;
dir[0] = 0;
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_DIR:
if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) {
snd_strerror(htlc, err);
return;
}
break;
}
dh_end()
if (!fnlen && !dir[0]) {
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
if (dir[0]) {
if (fnlen)
snprintf(oldbuf, sizeof(oldbuf), "%s/%s", dir, filename);
else
strcpy(oldbuf, dir);
} else {
snprintf(oldbuf, sizeof(oldbuf), "%s/%s", ROOTDIR, filename);
}
if (check_dropbox(htlc, oldbuf)) {
snd_strerror(htlc, EPERM);
return;
}
if (log_delete)
hxd_log("%s:%s:%u - delete %s", htlc->name, htlc->login, htlc->uid, oldbuf);
if (SYS_lstat(oldbuf, &sb)) {
snd_strerror(htlc, errno);
return;
}
#if defined(CONFIG_HFS)
if (!hxd_cfg.operation.hfs)
goto skiphfs;
if (hxd_cfg.files.fork == HFS_FORK_CAP) {
if (!S_ISDIR(sb.st_mode) && !resource_path(rsrcpath_old, oldbuf, &rsb)
&& !S_ISDIR(rsb.st_mode)) {
if (unlink(rsrcpath_old)) {
snd_strerror(htlc, errno);
return;
}
}
}
if (!finderinfo_path(rsrcpath_old, oldbuf, &rsb)) {
if (unlink(rsrcpath_old)) {
snd_strerror(htlc, errno);
return;
}
}
skiphfs:
#endif /* CONFIG_HFS */
if (S_ISDIR(sb.st_mode) && !S_ISLNK(sb.st_mode))
err = recursive_rmdir(oldbuf);
else
err = unlink(oldbuf);
if (err)
snd_strerror(htlc, errno);
else
hlwrite(htlc, HTLS_HDR_TASK, 0, 0);
}
void
rcv_file_symlink (struct htlc_conn *htlc)
{
u_int16_t fnlen = 0, newfnlen = 0;
char dir[MAXPATHLEN], newdir[MAXPATHLEN],
filename[NAME_MAX], newfilename[NAME_MAX], oldbuf[MAXPATHLEN], newbuf[MAXPATHLEN];
char rsrcpath_old[MAXPATHLEN], rsrcpath_new[MAXPATHLEN];
struct stat rsb;
int err;
dir[0] = newdir[0] = 0;
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_FILE_RENAME:
newfnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(newfilename, dh_data, newfnlen);
break;
case HTLC_DATA_DIR:
if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) {
snd_strerror(htlc, err);
return;
}
break;
case HTLC_DATA_DIR_RENAME:
if ((err = hldir_to_path(dh, ROOTDIR, newdir, newdir))) {
snd_strerror(htlc, err);
return;
}
break;
}
dh_end()
if ((!dir[0] && !fnlen) || !newdir[0]) {
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
if (!dir[0])
strcpy(dir, ROOTDIR);
if (fnlen) {
snprintf(oldbuf, sizeof(oldbuf), "%s/%s", dir, filename);
snprintf(newbuf, sizeof(newbuf), "%s/%s", newdir, newfnlen ? newfilename : filename);
} else {
strcpy(oldbuf, dir);
strcpy(newbuf, newdir);
}
if (check_dropbox(htlc, oldbuf)) {
snd_strerror(htlc, EPERM);
return;
}
if (log_symlink)
hxd_log("%s:%s:%u - symlink %s to %s", htlc->name, htlc->login, htlc->uid, newbuf, oldbuf);
if (sys_symlink(oldbuf, newbuf))
snd_strerror(htlc, errno);
else
hlwrite(htlc, HTLS_HDR_TASK, 0, 0);
#if defined(CONFIG_HFS)
if (!hxd_cfg.operation.hfs)
return;
if (hxd_cfg.files.fork == HFS_FORK_CAP) {
if (!resource_path(rsrcpath_old, oldbuf, &rsb)) {
if ((err = resource_path(rsrcpath_new, newbuf, 0))) {
/* (void)unlink(newbuf); */
snd_strerror(htlc, err);
return;
} else {
if (sys_symlink(rsrcpath_old, rsrcpath_new)) {
/* (void)unlink(newbuf); */
snd_strerror(htlc, errno);
return;
}
}
}
}
if (!finderinfo_path(rsrcpath_old, oldbuf, &rsb)) {
if ((err = finderinfo_path(rsrcpath_new, newbuf, 0))) {
/* (void)unlink(newbuf); */
snd_strerror(htlc, err);
return;
} else {
if (sys_symlink(rsrcpath_old, rsrcpath_new)) {
/* (void)unlink(newbuf); */
snd_strerror(htlc, errno);
return;
}
}
}
#endif /* CONFIG_HFS */
}
void
rcv_file_move (struct htlc_conn *htlc)
{
u_int16_t fnlen = 0;
char dir[MAXPATHLEN], newdir[MAXPATHLEN],
filename[NAME_MAX], oldbuf[MAXPATHLEN], newbuf[MAXPATHLEN];
char rsrcpath_old[MAXPATHLEN], rsrcpath_new[MAXPATHLEN];
struct stat sb, rsb;
int err;
dev_t diff_device;
dir[0] = newdir[0] = 0;
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_DIR:
if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) {
snd_strerror(htlc, err);
return;
}
break;
case HTLC_DATA_DIR_RENAME:
if ((err = hldir_to_path(dh, ROOTDIR, newdir, newdir))) {
snd_strerror(htlc, err);
return;
}
break;
}
dh_end()
if ((!dir[0] && !fnlen) || !newdir[0]) {
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
if (!dir[0])
strcpy(dir, ROOTDIR);
if (fnlen) {
snprintf(oldbuf, sizeof(oldbuf), "%s/%s", dir, filename);
snprintf(newbuf, sizeof(newbuf), "%s/%s", newdir, filename);
} else {
strcpy(oldbuf, dir);
strcpy(newbuf, newdir);
}
if (check_dropbox(htlc, oldbuf) || check_dropbox(htlc, newbuf)) {
snd_strerror(htlc, EPERM);
return;
}
if (stat(oldbuf, &sb)) {
snd_strerror(htlc, errno);
return;
}
if (S_ISDIR(sb.st_mode)) {
if (!htlc->access.move_folders) {
snd_strerror(htlc, EPERM);
return;
}
} else {
if (!htlc->access.move_files) {
snd_strerror(htlc, EPERM);
return;
}
}
if (log_move)
hxd_log("%s:%s:%u - move %s to %s", htlc->name, htlc->login, htlc->uid, oldbuf, newbuf);
diff_device = sb.st_dev;
if (stat(newdir, &sb)) {
snd_strerror(htlc, errno);
return;
}
#if 0 /* gcc on hpux does not like this */
diff_device &= ~sb.st_dev;
#else
diff_device = diff_device != sb.st_dev;
#endif
if (diff_device ? copy_and_unlink(oldbuf, newbuf) : rename(oldbuf, newbuf)) {
snd_strerror(htlc, errno);
return;
}
#if defined(CONFIG_HFS)
if (!hxd_cfg.operation.hfs)
goto ret;
if (hxd_cfg.files.fork == HFS_FORK_CAP) {
if (!resource_path(rsrcpath_old, oldbuf, &rsb)) {
if ((err = resource_path(rsrcpath_new, newbuf, 0))) {
/* (void)rename(newbuf, oldbuf); */
snd_strerror(htlc, err);
return;
} else {
if (diff_device ? copy_and_unlink(rsrcpath_old, rsrcpath_new) : rename(rsrcpath_old, rsrcpath_new)) {
/* (void)rename(newbuf, oldbuf); */
snd_strerror(htlc, errno);
return;
}
}
}
}
if (!finderinfo_path(rsrcpath_old, oldbuf, &rsb)) {
if ((err = finderinfo_path(rsrcpath_new, newbuf, 0))) {
/* (void)rename(newbuf, oldbuf); */
snd_strerror(htlc, err);
return;
} else {
if (diff_device ? copy_and_unlink(rsrcpath_old, rsrcpath_new) : rename(rsrcpath_old, rsrcpath_new)) {
/* (void)rename(newbuf, oldbuf); */
snd_strerror(htlc, errno);
return;
}
}
}
ret:
#endif /* CONFIG_HFS */
hlwrite(htlc, HTLS_HDR_TASK, 0, 0);
}
void
rcv_file_setinfo (struct htlc_conn *htlc)
{
u_int16_t fnlen = 0, newfnlen = 0, comlen = 0;
char dir[MAXPATHLEN], oldbuf[MAXPATHLEN], newbuf[MAXPATHLEN],
filename[NAME_MAX], newfilename[NAME_MAX];
char rsrcpath_old[MAXPATHLEN], rsrcpath_new[MAXPATHLEN];
u_int8_t comment[200];
struct stat sb;
int err;
dir[0] = 0;
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_FILE_RENAME:
newfnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(newfilename, dh_data, newfnlen);
break;
case HTLC_DATA_DIR:
if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) {
snd_strerror(htlc, err);
return;
}
break;
case HTLC_DATA_FILE_COMMENT:
comlen = dh_len > 255 ? 255 : dh_len;
memcpy(comment, dh_data, comlen);
break;
}
dh_end()
if (!fnlen || (!newfnlen && !comlen)) {
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
snprintf(oldbuf, sizeof(oldbuf), "%s/%s", dir[0] ? dir : ROOTDIR, filename);
if (stat(oldbuf, &sb)) {
snd_strerror(htlc, errno);
return;
}
if (check_dropbox(htlc, oldbuf)) {
snd_strerror(htlc, EPERM);
return;
}
#if defined(CONFIG_HFS)
if (hxd_cfg.operation.hfs && comlen) {
if (S_ISDIR(sb.st_mode)) {
if (!htlc->access.comment_folders) {
snd_strerror(htlc, EPERM);
return;
}
} else {
if (!htlc->access.comment_files) {
snd_strerror(htlc, EPERM);
return;
}
}
if (log_comment)
hxd_log("%s:%s:%u - comment %s to %.*s", htlc->name, htlc->login, htlc->uid, oldbuf, comlen, comment);
comment_write(oldbuf, comment, comlen);
}
#endif
if (!newfnlen)
goto ret;
if (dir[0])
snprintf(newbuf, sizeof(newbuf), "%s/%s", dir, newfilename);
else
snprintf(newbuf, sizeof(newbuf), "%s/%s", ROOTDIR, newfilename);
if (S_ISDIR(sb.st_mode)) {
if (!htlc->access.rename_folders) {
snd_strerror(htlc, EPERM);
return;
}
} else {
if (!htlc->access.rename_files) {
snd_strerror(htlc, EPERM);
return;
}
}
if (log_rename)
hxd_log("%s:%s:%u - rename %s to %s", htlc->name, htlc->login, htlc->uid, oldbuf, newbuf);
if (rename(oldbuf, newbuf)) {
snd_strerror(htlc, errno);
return;
}
#if defined(CONFIG_HFS)
if (!hxd_cfg.operation.hfs)
goto ret;
if (hxd_cfg.files.fork == HFS_FORK_CAP) {
if (!resource_path(rsrcpath_old, oldbuf, &sb)) {
if ((err = resource_path(rsrcpath_new, newbuf, 0))) {
/* (void)rename(newbuf, oldbuf); */
snd_strerror(htlc, err);
return;
} else {
if (rename(rsrcpath_old, rsrcpath_new)) {
/* (void)rename(newbuf, oldbuf); */
snd_strerror(htlc, errno);
return;
}
}
}
}
if (!finderinfo_path(rsrcpath_old, oldbuf, &sb)) {
if ((err = finderinfo_path(rsrcpath_new, newbuf, 0))) {
/* (void)rename(newbuf, oldbuf); */
snd_strerror(htlc, err);
return;
} else {
if (rename(rsrcpath_old, rsrcpath_new)) {
/* (void)rename(newbuf, oldbuf); */
snd_strerror(htlc, errno);
return;
}
}
}
#endif /* CONFIG_HFS */
ret:
hlwrite(htlc, HTLS_HDR_TASK, 0, 0);
}
//****************************************对抽取的语料库按类别进行分类****************************************
void corpus_category(string filename_path, string path_read, string path_write) //参数1：文件名列表路径 参数2：读取文件的目录 参数3：写入文件的目录
{
string file_name; //存储读取的各个文件的名字
ifstream read_filename(filename_path); //从LIST.TXT读取文件名
ofstream sports(path_write+"sports.txt");//属于sport类的存放在sport.txt文件中
ofstream house(path_write+"house.txt");
ofstream it(path_write+"it.txt");
ofstream test_2008(path_write+"2008.txt");
ofstream news(path_write+"news.txt");
ofstream yule(path_write+"yule.txt");
ofstream business(path_write+"business.txt");
ofstream travel(path_write+"travel.txt");
ofstream mil_news(path_write+"mil.news.txt");
ofstream women(path_write+"women.txt");
ofstream health(path_write+"health.txt");
ofstream test_auto(path_write+"auto.txt");
ofstream cul(path_write+"cul.txt");
ofstream learning(path_write+"learning.txt");
ofstream test_else(path_write+"else.txt");
string path_in, str_line,cut_str;//path_in:存放读文件路径 str_line:读取的一行文件 cut_str:存放截取的字符串
string::size_type pos1, pos2;
int number = 0;
while (getline(read_filename, file_name))
{
number++;
cout << number << endl;
path_in = path_read + file_name;
ifstream infile(path_in);
while (getline(infile, str_line)) //读取各个文件的每一行字符串
{
pos1 = 0;
pos2 = str_line.find("####");
cut_str = str_line.substr(pos1, pos2 - pos1);
if (string(cut_str) == string("sports")) //字符串匹配 是否为sports类
{
sports << str_line << endl; //如果是sports类就把该行输出到sports.txt文件
}
else if (cut_str == "house")
{
house << str_line << endl;
}
else if (cut_str == "it")
{
it << str_line << endl;
}
else if (cut_str == "2008")
{
test_2008 << str_line << endl;
}
else if (cut_str == "news")
{
news << str_line << endl;
}
else if (cut_str == "yule")
{
yule << str_line << endl;
}
else if (cut_str == "business")
{
business << str_line << endl;
}
else if (cut_str == "travel")
{
travel << str_line << endl;
}
else if (cut_str == "mil.news")
{
mil_news << str_line << endl;
}
else if (cut_str == "women")
{
women << str_line << endl;
}
else if (cut_str == "health")
{
health << str_line << endl;
}
else if (cut_str == "auto")
{
test_auto << str_line << endl;
}
else if (cut_str == "cul")
{
cul << str_line << endl;
}
else if (cut_str == "learning")
{
learning << str_line << endl;
}
else
{
test_else << str_line << endl;
}
}
infile.close(); //每次结束都得关闭文件.
}
}
/* Process command key. Returns non-zero if command results in picocom
exit, zero otherwise. */
int
do_command (unsigned char c)
{
static int dtr_up = 0;
int newbaud, newflow, newparity, newbits, newstopbits;
const char *xfr_cmd;
char *fname;
int r;
switch (c) {
case KEY_EXIT:
return 1;
case KEY_QUIT:
term_set_hupcl(tty_fd, 0);
term_flush(tty_fd);
term_apply(tty_fd, 1);
term_erase(tty_fd);
return 1;
case KEY_STATUS:
show_status(dtr_up);
break;
case KEY_HELP:
case KEY_KEYS:
show_keys();
break;
case KEY_PULSE:
fd_printf(STO, "\r\n*** pulse DTR ***\r\n");
if ( term_pulse_dtr(tty_fd) < 0 )
fd_printf(STO, "*** FAILED\r\n");
break;
case KEY_TOGGLE:
if ( dtr_up )
r = term_lower_dtr(tty_fd);
else
r = term_raise_dtr(tty_fd);
if ( r >= 0 ) dtr_up = ! dtr_up;
fd_printf(STO, "\r\n*** DTR: %s ***\r\n",
dtr_up ? "up" : "down");
break;
case KEY_BAUD:
case KEY_BAUD_UP:
case KEY_BAUD_DN:
if ( c== KEY_BAUD) {
newbaud = read_baud();
if ( newbaud < 0 ) {
fd_printf(STO, "*** cannot read baudrate ***\r\n");
break;
}
opts.baud = newbaud;
} else if (c == KEY_BAUD_UP) {
opts.baud = baud_up(opts.baud);
} else {
opts.baud = baud_down(opts.baud);
}
term_set_baudrate(tty_fd, opts.baud);
tty_q.len = 0; term_flush(tty_fd);
term_apply(tty_fd, 1);
newbaud = term_get_baudrate(tty_fd, NULL);
if ( opts.baud != newbaud ) {
fd_printf(STO, "\r\n*** baud: %d (%d) ***\r\n",
opts.baud, newbaud);
} else {
fd_printf(STO, "\r\n*** baud: %d ***\r\n", opts.baud);
}
set_tty_write_sz(newbaud);
break;
case KEY_FLOW:
opts.flow = flow_next(opts.flow);
term_set_flowcntrl(tty_fd, opts.flow);
tty_q.len = 0; term_flush(tty_fd);
term_apply(tty_fd, 1);
newflow = term_get_flowcntrl(tty_fd);
if ( opts.flow != newflow ) {
fd_printf(STO, "\r\n*** flow: %s (%s) ***\r\n",
flow_str[opts.flow], flow_str[newflow]);
} else {
fd_printf(STO, "\r\n*** flow: %s ***\r\n",
flow_str[opts.flow]);
}
break;
case KEY_PARITY:
opts.parity = parity_next(opts.parity);
term_set_parity(tty_fd, opts.parity);
tty_q.len = 0; term_flush(tty_fd);
term_apply(tty_fd, 1);
newparity = term_get_parity(tty_fd);
if (opts.parity != newparity ) {
fd_printf(STO, "\r\n*** parity: %s (%s) ***\r\n",
parity_str[opts.parity],
parity_str[newparity]);
} else {
fd_printf(STO, "\r\n*** parity: %s ***\r\n",
parity_str[opts.parity]);
}
break;
case KEY_BITS:
opts.databits = bits_next(opts.databits);
term_set_databits(tty_fd, opts.databits);
tty_q.len = 0; term_flush(tty_fd);
term_apply(tty_fd, 1);
newbits = term_get_databits(tty_fd);
if (opts.databits != newbits ) {
fd_printf(STO, "\r\n*** databits: %d (%d) ***\r\n",
opts.databits, newbits);
} else {
fd_printf(STO, "\r\n*** databits: %d ***\r\n",
opts.databits);
}
break;
case KEY_STOP:
opts.stopbits = stopbits_next(opts.stopbits);
term_set_stopbits(tty_fd, opts.stopbits);
tty_q.len = 0; term_flush(tty_fd);
term_apply(tty_fd, 1);
newstopbits = term_get_stopbits(tty_fd);
if (opts.stopbits != newstopbits ) {
fd_printf(STO, "\r\n*** stopbits: %d (%d) ***\r\n",
opts.stopbits, newstopbits);
} else {
fd_printf(STO, "\r\n*** stopbits: %d ***\r\n",
opts.stopbits);
}
break;
case KEY_LECHO:
opts.lecho = ! opts.lecho;
fd_printf(STO, "\r\n*** local echo: %s ***\r\n",
opts.lecho ? "yes" : "no");
break;
case KEY_SEND:
case KEY_RECEIVE:
xfr_cmd = (c == KEY_SEND) ? opts.send_cmd : opts.receive_cmd;
if ( xfr_cmd[0] == '\0' ) {
fd_printf(STO, "\r\n*** command disabled ***\r\n");
break;
}
fname = read_filename();
if (fname == NULL) {
fd_printf(STO, "*** cannot read filename ***\r\n");
break;
}
run_cmd(tty_fd, xfr_cmd, fname);
free(fname);
break;
case KEY_BREAK:
term_break(tty_fd);
fd_printf(STO, "\r\n*** break sent ***\r\n");
break;
default:
break;
}
return 0;
}
int main(int argc, const char** argv) {
DB_APP app;
DB_WORKUNIT wu;
int retval;
char wu_template[BLOB_SIZE];
char wu_template_file[256], result_template_file[256], result_template_path[1024];
const char* command_line=NULL;
const char** infiles = NULL;
int i, ninfiles;
char download_dir[256], db_name[256], db_passwd[256];
char db_user[256],db_host[256];
char buf[256];
char additional_xml[256];
bool assign_flag = false;
bool assign_multi = false;
int assign_id = 0;
int assign_type;
strcpy(result_template_file, "");
strcpy(app.name, "");
strcpy(db_passwd, "");
strcpy(additional_xml, "");
const char* config_dir = 0;
i = 1;
ninfiles = 0;
wu.clear();
// defaults (in case they're not in WU template)
wu.id = 0;
wu.min_quorum = 2;
wu.target_nresults = 2;
wu.max_error_results = 3;
wu.max_total_results = 10;
wu.max_success_results = 6;
wu.rsc_fpops_est = 3600e9;
wu.rsc_fpops_bound = 86400e9;
wu.rsc_memory_bound = 5e8;
wu.rsc_disk_bound = 1e9;
wu.rsc_bandwidth_bound = 0.0;
wu.delay_bound = 7*86400;
while (i < argc) {
if (arg(argv, i, "appname")) {
strcpy(app.name, argv[++i]);
} else if (arg(argv, i, "wu_name")) {
strcpy(wu.name, argv[++i]);
} else if (arg(argv, i, "wu_template")) {
strcpy(wu_template_file, argv[++i]);
} else if (arg(argv, i, "result_template")) {
strcpy(result_template_file, argv[++i]);
} else if (arg(argv, i, "batch")) {
wu.batch = atoi(argv[++i]);
} else if (arg(argv, i, "config_dir")) {
config_dir = argv[++i];
} else if (arg(argv, i, "batch")) {
wu.batch = atoi(argv[++i]);
} else if (arg(argv, i, "priority")) {
wu.priority = atoi(argv[++i]);
} else if (arg(argv, i, "rsc_fpops_est")) {
wu.rsc_fpops_est = atof(argv[++i]);
} else if (arg(argv, i, "rsc_fpops_bound")) {
wu.rsc_fpops_bound = atof(argv[++i]);
} else if (arg(argv, i, "rsc_memory_bound")) {
wu.rsc_memory_bound = atof(argv[++i]);
} else if (arg(argv, i, "rsc_disk_bound")) {
wu.rsc_disk_bound = atof(argv[++i]);
} else if (arg(argv, i, "delay_bound")) {
wu.delay_bound = atoi(argv[++i]);
} else if (arg(argv, i, "min_quorum")) {
wu.min_quorum = atoi(argv[++i]);
} else if (arg(argv, i, "target_nresults")) {
wu.target_nresults = atoi(argv[++i]);
} else if (arg(argv, i, "max_error_results")) {
wu.max_error_results = atoi(argv[++i]);
} else if (arg(argv, i, "max_total_results")) {
wu.max_total_results = atoi(argv[++i]);
} else if (arg(argv, i, "max_success_results")) {
wu.max_success_results = atoi(argv[++i]);
} else if (arg(argv, i, "opaque")) {
wu.opaque = atoi(argv[++i]);
} else if (arg(argv, i, "command_line")) {
command_line= argv[++i];
} else if (arg(argv, i, "additional_xml")) {
strcpy(additional_xml, argv[++i]);
} else if (arg(argv, i, "wu_id")) {
wu.id = atoi(argv[++i]);
} else if (arg(argv, i, "assign_all")) {
assign_multi = true;
assign_flag = true;
assign_type = ASSIGN_NONE;
} else if (arg(argv, i, "assign_host")) {
assign_flag = true;
assign_type = ASSIGN_HOST;
assign_id = atoi(argv[++i]);
} else if (arg(argv, i, "assign_user_one")) {
assign_flag = true;
assign_type = ASSIGN_USER;
assign_id = atoi(argv[++i]);
} else if (arg(argv, i, "assign_user_all")) {
assign_flag = true;
assign_type = ASSIGN_USER;
assign_multi = true;
assign_id = atoi(argv[++i]);
} else if (arg(argv, i, "assign_team_one")) {
assign_flag = true;
assign_type = ASSIGN_TEAM;
assign_id = atoi(argv[++i]);
} else if (arg(argv, i, "assign_team_all")) {
assign_flag = true;
assign_type = ASSIGN_TEAM;
assign_multi = true;
assign_id = atoi(argv[++i]);
} else {
if (!strncmp("-", argv[i], 1)) {
fprintf(stderr, "create_work: bad argument '%s'\n", argv[i]);
exit(1);
}
infiles = argv+i;
ninfiles = argc - i;
break;
}
i++;
}
#define CHKARG(x,m) do { if (!(x)) { fprintf(stderr, "create_work: bad command line: "m"\n"); exit(1); } } while (0)
#define CHKARG_STR(v,m) CHKARG(strlen(v),m)
CHKARG_STR(app.name , "need --appname");
CHKARG_STR(wu.name , "need --wu_name");
CHKARG_STR(wu_template_file , "need --wu_template");
CHKARG_STR(result_template_file , "need --result_template");
#undef CHKARG
#undef CHKARG_STR
if (assign_flag) {
if (!strstr(wu.name, ASSIGNED_WU_STR)) {
fprintf(stderr,
"Assigned WU names must contain '%s'\n", ASSIGNED_WU_STR
);
exit(1);
}
}
retval = config.parse_file();
if (retval) {
fprintf(stderr, "Can't parse config file: %d\n", retval);
exit(1);
} else {
strcpy(db_name, config.db_name);
strcpy(db_passwd, config.db_passwd);
strcpy(db_user, config.db_user);
strcpy(db_host, config.db_host);
strcpy(download_dir, config.download_dir);
}
retval = boinc_db.open(db_name, db_host, db_user, db_passwd);
if (retval) {
fprintf(stderr, "create_work: error opening database: %d\n", retval );
exit(1);
}
sprintf(buf, "where name='%s'", app.name);
retval = app.lookup(buf);
if (retval) {
fprintf(stderr, "create_work: app not found\n");
exit(1);
}
retval = read_filename(wu_template_file, wu_template, sizeof(wu_template));
if (retval) {
fprintf(stderr, "create_work: can't open WU template: %d\n", retval);
exit(1);
}
wu.appid = app.id;
strcpy(result_template_path, "./");
strcat(result_template_path, result_template_file);
retval = create_work(
wu,
wu_template,
result_template_file,
result_template_path,
const_cast<const char **>(infiles),
ninfiles,
config,
command_line,
additional_xml
);
if (retval) {
fprintf(stderr, "create_work: %d\n", retval);
exit(1);
}
if (assign_flag) {
DB_ASSIGNMENT assignment;
assignment.clear();
assignment.create_time = time(0);
assignment.target_id = assign_id;
assignment.target_type = assign_type;
assignment.multi = assign_multi;
assignment.workunitid = wu.id;
retval = assignment.insert();
if (retval) {
fprintf(stderr, "assignment.insert() failed: %d\n", retval);
exit(1);
}
}
boinc_db.close();
}
void
rcv_file_getinfo (struct htlc_conn *htlc)
{
u_int32_t size;
u_int8_t date_create[8], date_modify[8];
u_int16_t fnlen = 0;
char dir[MAXPATHLEN], filename[NAME_MAX], path[MAXPATHLEN];
struct stat sb;
int is_link;
int err;
u_int16_t file_typelen, file_creatorlen;
u_int8_t file_type[12], file_creator[4];
u_int32_t mactime;
#if defined(CONFIG_HFS)
struct hfsinfo fi;
#endif
dir[0] = 0;
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len > NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_DIR:
if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) {
snd_strerror(htlc, err);
return;
}
break;
}
dh_end()
if (!fnlen && !dir[0]) {
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
if (dir[0]) {
if (fnlen)
snprintf(path, sizeof(path), "%s/%s", dir, filename);
else {
int i, len = strlen(dir);
for (i = len - 1; i > 0; i--)
if (dir[i] == DIRCHAR) {
fnlen = len - i > NAME_MAX ? NAME_MAX : len - i;
strcpy(filename, &dir[len - fnlen + 1]);
break;
}
strcpy(path, dir);
}
} else {
snprintf(path, sizeof(path), "%s/%s", ROOTDIR, filename);
}
#ifdef HAVE_CORESERVICES
resolve_alias_path(path, path);
#endif
if (check_dropbox(htlc, path)) {
snd_strerror(htlc, EPERM);
return;
}
if (log_getinfo)
hxd_log("%s:%s:%u - getinfo %s", htlc->name, htlc->login, htlc->uid, path);
if (SYS_lstat(path, &sb)) {
broken_alias: snd_strerror(htlc, errno);
return;
}
if (S_ISLNK(sb.st_mode)) {
is_link = 1;
if (stat(path, &sb))
goto broken_alias;
} else {
is_link = 0;
}
size = sb.st_size;
#if defined(CONFIG_HFS)
if (hxd_cfg.operation.hfs)
size += resource_len(path);
#endif
size = htonl(size);
memset(date_create, 0, 8);
memset(date_modify, 0, 8);
#if defined(CONFIG_HFS)
if (!hxd_cfg.operation.hfs)
goto skiphfs;
hfsinfo_read(path, &fi);
mactime = hfs_h_to_mtime(fi.create_time);
*((u_int16_t *)date_create) = htons(1904);
*((u_int32_t *)(date_create+4)) = mactime;
mactime = hfs_h_to_mtime(fi.modify_time);
*((u_int16_t *)date_modify) = htons(1904);
*((u_int32_t *)(date_modify+4)) = mactime;
file_typelen = 4;
file_creatorlen = 4;
if (S_ISDIR(sb.st_mode)) {
#if 0
if (is_link) {
file_typelen = 12;
memcpy(file_type, "Folder Alias", file_typelen);
} else
memcpy(file_type, "fldr", 4);
#endif
memcpy(fi.type, "fldr", 4);
memcpy(file_type, "fldr", 4);
memcpy(file_creator, "n/a ", 4);
} else {
memcpy(file_type, fi.type, 4);
memcpy(file_creator, fi.creator, 4);
}
if (is_link) {
memcpy(file_type, "\0\0\0\0", 4);
file_typelen = 4;
}
hlwrite(htlc, HTLS_HDR_TASK, 0, 8,
HTLS_DATA_FILE_ICON, 4, fi.type,
HTLS_DATA_FILE_TYPE, file_typelen, file_type,
HTLS_DATA_FILE_CREATOR, file_creatorlen, file_creator,
HTLS_DATA_FILE_SIZE, sizeof(size), &size,
HTLS_DATA_FILE_NAME, fnlen, filename,
HTLS_DATA_FILE_DATE_CREATE, 8, date_create,
HTLS_DATA_FILE_DATE_MODIFY, 8, date_modify,
HTLS_DATA_FILE_COMMENT, fi.comlen > 200 ? 200 : fi.comlen, fi.comment);
return;
skiphfs:
#endif
mactime = htonl(sb.st_mtime + 2082844800);
*((u_int16_t *)date_modify) = 1904;
*((u_int32_t *)(date_modify+4)) = mactime;
hlwrite(htlc, HTLS_HDR_TASK, 0, 3,
HTLS_DATA_FILE_SIZE, sizeof(size), &size,
HTLS_DATA_FILE_NAME, fnlen, filename,
HTLS_DATA_FILE_DATE_MODIFY, 8, date_modify);
}
int main(int argc, const char** argv) {
DB_APP app;
DB_WORKUNIT wu;
int retval;
char wu_template[BLOB_SIZE];
char wu_template_file[256], result_template_file[256], result_template_path[MAXPATHLEN];
const char* command_line=NULL;
const char** infiles = NULL;
int i, ninfiles;
char download_dir[256], db_name[256], db_passwd[256];
char db_user[256],db_host[256];
char buf[256];
char additional_xml[256];
bool show_wu_name = true;
bool assign_flag = false;
bool assign_multi = false;
int assign_id = 0;
int assign_type = ASSIGN_NONE;
strcpy(wu_template_file, "");
strcpy(result_template_file, "");
strcpy(app.name, "");
strcpy(db_passwd, "");
strcpy(additional_xml, "");
const char* config_dir = 0;
i = 1;
ninfiles = 0;
wu.clear();
// defaults (in case they're not in WU template)
wu.id = 0;
wu.min_quorum = 2;
wu.target_nresults = 2;
wu.max_error_results = 3;
wu.max_total_results = 10;
wu.max_success_results = 6;
wu.rsc_fpops_est = 3600e9;
wu.rsc_fpops_bound = 86400e9;
wu.rsc_memory_bound = 5e8;
wu.rsc_disk_bound = 1e9;
wu.rsc_bandwidth_bound = 0.0;
wu.delay_bound = 7*86400;
while (i < argc) {
if (arg(argv, i, "appname")) {
strcpy(app.name, argv[++i]);
} else if (arg(argv, i, "d")) {
int dl = atoi(argv[++i]);
log_messages.set_debug_level(dl);
if (dl ==4) g_print_queries = true;
} else if (arg(argv, i, "wu_name")) {
show_wu_name = false;
strcpy(wu.name, argv[++i]);
} else if (arg(argv, i, "wu_template")) {
strcpy(wu_template_file, argv[++i]);
} else if (arg(argv, i, "result_template")) {
strcpy(result_template_file, argv[++i]);
} else if (arg(argv, i, "batch")) {
wu.batch = atoi(argv[++i]);
} else if (arg(argv, i, "config_dir")) {
config_dir = argv[++i];
} else if (arg(argv, i, "batch")) {
wu.batch = atoi(argv[++i]);
} else if (arg(argv, i, "priority")) {
wu.priority = atoi(argv[++i]);
} else if (arg(argv, i, "rsc_fpops_est")) {
wu.rsc_fpops_est = atof(argv[++i]);
} else if (arg(argv, i, "rsc_fpops_bound")) {
wu.rsc_fpops_bound = atof(argv[++i]);
} else if (arg(argv, i, "rsc_memory_bound")) {
wu.rsc_memory_bound = atof(argv[++i]);
} else if (arg(argv, i, "rsc_disk_bound")) {
wu.rsc_disk_bound = atof(argv[++i]);
} else if (arg(argv, i, "delay_bound")) {
wu.delay_bound = atoi(argv[++i]);
} else if (arg(argv, i, "min_quorum")) {
wu.min_quorum = atoi(argv[++i]);
} else if (arg(argv, i, "target_nresults")) {
wu.target_nresults = atoi(argv[++i]);
} else if (arg(argv, i, "max_error_results")) {
wu.max_error_results = atoi(argv[++i]);
} else if (arg(argv, i, "max_total_results")) {
wu.max_total_results = atoi(argv[++i]);
} else if (arg(argv, i, "max_success_results")) {
wu.max_success_results = atoi(argv[++i]);
} else if (arg(argv, i, "opaque")) {
wu.opaque = atoi(argv[++i]);
} else if (arg(argv, i, "command_line")) {
command_line= argv[++i];
} else if (arg(argv, i, "additional_xml")) {
strcpy(additional_xml, argv[++i]);
} else if (arg(argv, i, "wu_id")) {
wu.id = atoi(argv[++i]);
} else if (arg(argv, i, "broadcast")) {
assign_multi = true;
assign_flag = true;
assign_type = ASSIGN_NONE;
} else if (arg(argv, i, "broadcast_user")) {
assign_flag = true;
assign_type = ASSIGN_USER;
assign_multi = true;
assign_id = atoi(argv[++i]);
} else if (arg(argv, i, "broadcast_team")) {
assign_flag = true;
assign_type = ASSIGN_TEAM;
assign_multi = true;
assign_id = atoi(argv[++i]);
} else if (arg(argv, i, "target_host")) {
assign_flag = true;
assign_type = ASSIGN_HOST;
assign_id = atoi(argv[++i]);
} else if (arg(argv, i, "target_user")) {
assign_flag = true;
assign_type = ASSIGN_USER;
assign_id = atoi(argv[++i]);
} else if (arg(argv, i, "target_team")) {
assign_flag = true;
assign_type = ASSIGN_TEAM;
assign_id = atoi(argv[++i]);
} else if (arg(argv, i, "help")) {
usage();
exit(0);
} else {
if (!strncmp("-", argv[i], 1)) {
fprintf(stderr, "create_work: bad argument '%s'\n", argv[i]);
exit(1);
}
infiles = argv+i;
ninfiles = argc - i;
break;
}
i++;
}
if (!strlen(app.name)) {
usage();
}
if (!strlen(wu.name)) {
sprintf(wu.name, "%s_%d_%f", app.name, getpid(), dtime());
}
if (!strlen(wu_template_file)) {
sprintf(wu_template_file, "templates/%s_in", app.name);
}
if (!strlen(result_template_file)) {
sprintf(result_template_file, "templates/%s_out", app.name);
}
retval = config.parse_file(config_dir);
if (retval) {
fprintf(stderr, "Can't parse config file: %s\n", boincerror(retval));
exit(1);
} else {
strcpy(db_name, config.db_name);
strcpy(db_passwd, config.db_passwd);
strcpy(db_user, config.db_user);
strcpy(db_host, config.db_host);
strcpy(download_dir, config.download_dir);
}
retval = boinc_db.open(db_name, db_host, db_user, db_passwd);
if (retval) {
fprintf(stderr,
"create_work: error opening database: %s\n", boincerror(retval)
);
exit(1);
}
sprintf(buf, "where name='%s'", app.name);
retval = app.lookup(buf);
if (retval) {
fprintf(stderr, "create_work: app not found\n");
exit(1);
}
retval = read_filename(wu_template_file, wu_template, sizeof(wu_template));
if (retval) {
fprintf(stderr,
"create_work: can't open input template %s\n", wu_template_file
);
exit(1);
}
wu.appid = app.id;
strcpy(result_template_path, "./");
strcat(result_template_path, result_template_file);
retval = create_work(
wu,
wu_template,
result_template_file,
result_template_path,
const_cast<const char **>(infiles),
ninfiles,
config,
command_line,
additional_xml
);
if (retval) {
fprintf(stderr, "create_work: %s\n", boincerror(retval));
exit(1);
} else {
if (show_wu_name) {
printf("workunit name: %s\n", wu.name);
}
}
if (assign_flag) {
DB_ASSIGNMENT assignment;
assignment.clear();
assignment.create_time = time(0);
assignment.target_id = assign_id;
assignment.target_type = assign_type;
assignment.multi = assign_multi;
assignment.workunitid = wu.id;
retval = assignment.insert();
if (retval) {
fprintf(stderr,
"assignment.insert() failed: %s\n", boincerror(retval)
);
exit(1);
}
sprintf(buf, "transitioner_flags=%d",
assign_multi?TRANSITION_NONE:TRANSITION_NO_NEW_RESULTS
);
retval = wu.update_field(buf);
if (retval) {
fprintf(stderr, "wu.update() failed: %s\n", boincerror(retval));
exit(1);
}
}
boinc_db.close();
}
GByteArray *JarFile::get_next_file_contents()
{
guint8 *bytes;
GByteArray *gba = g_byte_array_new();
read_signature();
//get compressed size
bytes = (guint8 *)g_malloc(sizeof(guint8) * 30);
if (!read(bytes+4, 26)) {
g_free(bytes);
return NULL;
}
guint32 compressed_size = UNPACK_UB4(bytes, LOC_CSIZE);
guint16 filename_length = UNPACK_UB2(bytes, LOC_FNLEN);
guint16 eflen = UNPACK_UB2(bytes, LOC_EFLEN);
guint16 flags = UNPACK_UB2(bytes, LOC_EXTRA);
guint16 method = UNPACK_UB2(bytes, LOC_COMP);
if (filename_length == 0) {
g_byte_array_free(gba, TRUE);
if (_last_filename != NULL)
g_free(_last_filename);
_last_filename = NULL;
g_free(bytes);
return NULL;
}
#ifdef DEBUG
std::printf("Compressed size is %u\n", compressed_size);
std::printf("Filename length is %hu\n", filename_length);
std::printf("Extra field length is %hu\n", eflen);
std::printf("Flags are %#hx\n", flags);
std::printf("Compression method is %#hx\n", method);
#endif
guint32 crc = get_crc(bytes, flags);
gchar *filename = (gchar *)read_filename(filename_length);
g_free(bytes);
if (filename == NULL)
return NULL;
if (_last_filename != NULL)
g_free(_last_filename);
_last_filename = filename;
//check if this is a directory and skip
char *c_ptr;
if ((c_ptr = std::strrchr(filename, '/')) != NULL) {
if (*(++c_ptr) == '\0') {
return NULL;
}
}
if (!check_compression_method(method, flags)) {
std::fprintf(stderr, "error in jar file\n");
return NULL;
}
if (method == 8 || flags & 0x0008) {
unsigned int file_length = 0;//uncompressed file length
lseek(fd, eflen, SEEK_CUR);
guint8 *file_data = get_compressed_file(compressed_size, file_length,
crc, flags);
if (file_data == NULL) {
g_byte_array_free(gba, FALSE);
return NULL;
}
g_byte_array_append(gba, file_data, file_length);
} else if (method == 0) {
guint8 *file_data = get_uncompressed_file(compressed_size, crc,
eflen, flags);
if (file_data == NULL) {
g_byte_array_free(gba, TRUE);
return NULL;
}
g_byte_array_append(gba, file_data, compressed_size);
} else {
lseek(fd, compressed_size+eflen, SEEK_CUR);
g_byte_array_free(gba, FALSE);
return NULL;
}
return gba;
}
void
rcv_file_hash (struct htlc_conn *htlc)
{
u_int16_t fnlen = 0;
char dir[MAXPATHLEN], filename[NAME_MAX], pathbuf[MAXPATHLEN];
int err;
int fd;
u_int32_t data_len = 0, rsrc_len = 0;
u_int16_t haval_len = 16, haval_passes = 3, hash_types = 0;
u_int8_t md5[32], haval[64], sha1[40];
u_int16_t md5len, sha1len;
#if defined(CONFIG_HFS)
int rfd;
off_t off = -1; /* keep gcc happy */
#endif
dir[0] = 0;
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len > NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_DIR:
if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) {
snd_strerror(htlc, err);
return;
}
break;
case HTLC_DATA_RFLT:
if (dh_len >= 50)
L32NTOH(data_len, &dh_data[46]);
if (dh_len >= 66)
L32NTOH(rsrc_len, &dh_data[62]);
break;
case HTLC_DATA_HASH_MD5:
hash_types |= 0x01;
break;
case HTLC_DATA_HASH_HAVAL:
hash_types |= 0x02;
if (dh_len == 2) {
haval_len = dh_data[0];
haval_passes = dh_data[1];
}
if (haval_len > 32)
haval_len = 32;
if (haval_passes < 3)
haval_passes = 3;
if (haval_passes > 5)
haval_passes = 5;
break;
case HTLC_DATA_HASH_SHA1:
hash_types |= 0x04;
break;
}
dh_end()
if (!fnlen && !dir[0]) {
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
if (dir[0]) {
if (fnlen)
snprintf(pathbuf, sizeof(pathbuf), "%s/%s", dir, filename);
else
strcpy(pathbuf, dir);
} else {
snprintf(pathbuf, sizeof(pathbuf), "%s/%s", ROOTDIR, filename);
}
if (check_dropbox(htlc, pathbuf)) {
snd_strerror(htlc, EPERM);
return;
}
if (log_hash)
hxd_log("%s:%s:%u - hash %s", htlc->name, htlc->login, htlc->uid, pathbuf);
fd = SYS_open(pathbuf, O_RDONLY, 0);
if (fd < 0) {
snd_strerror(htlc, errno);
return;
}
#if defined(CONFIG_HFS)
if (hxd_cfg.operation.hfs) {
rfd = resource_open(pathbuf, O_RDONLY, 0);
if (rfd >= 0) {
off = lseek(rfd, 0, SEEK_CUR);
if (off == (off_t)-1) {
close(rfd);
rfd = -1;
}
}
} else {
rfd = -1;
}
#endif
if (hash_types & 0x01) {
memset(md5, 0, 32);
md5_fd(fd, data_len, &md5[0]);
#if defined(CONFIG_HFS)
if (rfd >= 0)
md5_fd(rfd, rsrc_len, &md5[16]);
#endif
}
if (hash_types & 0x02) {
memset(haval, 0, haval_len * 2);
lseek(fd, 0, SEEK_SET);
haval_fd(fd, data_len, &haval[0], haval_len * 8, haval_passes);
#if defined(CONFIG_HFS)
if (rfd >= 0) {
lseek(rfd, off, SEEK_SET);
haval_fd(rfd, rsrc_len, &haval[haval_len], haval_len * 8, haval_passes);
}
#endif
}
if (hash_types & 0x04) {
memset(sha1, 0, 40);
lseek(fd, 0, SEEK_SET);
sha_fd(fd, data_len, &sha1[0]);
#if defined(CONFIG_HFS)
if (rfd >= 0) {
lseek(rfd, off, SEEK_SET);
sha_fd(rfd, rsrc_len, &sha1[20]);
}
#endif
}
#if defined(CONFIG_HFS)
if (rfd >= 0)
close(rfd);
#endif
close(fd);
md5len = 16;
sha1len = 20;
#if defined(CONFIG_HFS)
if (hxd_cfg.operation.hfs) {
md5len = 32;
haval_len *= 2;
sha1len = 40;
}
#endif
hlwrite(htlc, HTLS_HDR_TASK, 0, 3,
HTLS_DATA_HASH_MD5, md5len, md5,
HTLS_DATA_HASH_HAVAL, haval_len, haval,
HTLS_DATA_HASH_SHA1, sha1len, sha1);
}
void
rcv_folder_put (struct htlc_conn *htlc)
{
u_int16_t fnlen = 0, resume = 0;
char path[MAXPATHLEN], dir[MAXPATHLEN], filename[NAME_MAX];
char abuf[HOSTLEN+1], buf[128];
struct stat sb;
int err, siz, len;
u_int32_t ref, data_pos = 0, rsrc_pos = 0, totalsize = 0, nfiles = 0;
u_int8_t rflt[74];
struct SOCKADDR_IN lsaddr;
struct htxf_conn *htxf;
u_int16_t i;
if (htlc->nr_puts >= htlc->put_limit) {
len = snprintf(buf, sizeof(buf), "%u at a time", htlc->put_limit);
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, len, buf);
return;
}
if (nr_puts >= hxd_cfg.limits.total_uploads) {
len = snprintf(buf, sizeof(buf), "maximum number of total uploads reached (%u >= %d)",
nr_gets, hxd_cfg.limits.total_uploads);
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, len, buf);
return;
}
for (i = 0; i < HTXF_PUT_MAX; i++)
if (!htlc->htxf_in[i])
break;
if (i == HTXF_PUT_MAX) {
snd_strerror(htlc, EAGAIN);
return;
}
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_DIR:
if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) {
snd_strerror(htlc, err);
return;
}
break;
case HTLC_DATA_FILE_PREVIEW:
dh_getint(resume);
break;
case HTLC_DATA_HTXF_SIZE:
dh_getint(totalsize);
break;
case HTLC_DATA_FILE_NFILES:
dh_getint(nfiles);
break;
}
dh_end()
if (!htlc->access.upload_anywhere && (!dir[0] || (!strcasestr(dir, "UPLOAD") && !strcasestr(dir, "DROP BOX")))) {
snd_strerror(htlc, EPERM);
return;
}
if (!fnlen && !dir[0]) {
/* No file name given */
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
if (dir[0]) {
if (fnlen)
snprintf(path, sizeof(path), "%s/%s", dir, filename);
else
strcpy(path, dir);
} else {
snprintf(path, sizeof(path), "%s/%s", ROOTDIR, filename);
}
#ifdef HAVE_CORESERVICES
resolve_alias_path(path, path);
#endif
if (!resume) {
if (!stat(path, &sb)) {
snd_strerror(htlc, EEXIST);
return;
}
if (errno != ENOENT) {
snd_strerror(htlc, errno);
return;
}
SYS_mkdir(path, hxd_cfg.permissions.directories);
} else {
if (stat(path, &sb)) {
snd_strerror(htlc, errno);
return;
}
if (!S_ISDIR(sb.st_mode)) {
snd_strerror(htlc, ENOTDIR);
return;
}
}
ref = htxf_ref_new(htlc);
ref = htonl(ref);
siz = sizeof(struct SOCKADDR_IN);
if (getsockname(htlc->fd, (struct sockaddr *)&lsaddr, &siz)) {
hxd_log("rcv_file_get: getsockname: %s", strerror(errno));
snd_strerror(htlc, errno);
return;
}
htxf = htxf_new(htlc, 1);
htxf->type = HTXF_TYPE_FOLDER;
htxf->data_pos = data_pos;
htxf->rsrc_pos = rsrc_pos;
htxf->total_size = totalsize;
htxf->ref = ref;
htxf->sockaddr = htlc->sockaddr;
htxf->listen_sockaddr = lsaddr;
htxf->listen_sockaddr.SIN_PORT = htons(ntohs(htxf->listen_sockaddr.SIN_PORT) + 1);
strcpy(htxf->path, path);
htlc->nr_puts++;
nr_puts++;
if (log_upload) {
inaddr2str(abuf, &htlc->sockaddr);
hxd_log("%s@%s:%u - %s:%u:%u:%s - upload %s:%08x", htlc->userid, abuf, ntohs(htlc->sockaddr.SIN_PORT),
htlc->name, htlc->icon, htlc->uid, htlc->login, htxf->path, htxf->ref);
}
if (!resume)
hlwrite(htlc, HTLS_HDR_TASK, 0, 1,
HTLS_DATA_HTXF_REF, sizeof(ref), &ref);
else
hlwrite(htlc, HTLS_HDR_TASK, 0, 2,
HTLS_DATA_RFLT, 74, rflt,
HTLS_DATA_HTXF_REF, sizeof(ref), &ref);
}
void
rcv_file_get (struct htlc_conn *htlc)
{
u_int16_t fnlen = 0, preview = 0;
char path[MAXPATHLEN], dir[MAXPATHLEN], filename[NAME_MAX];
char abuf[HOSTLEN+1], buf[128];
struct stat sb;
u_int32_t size = 0, data_size = 0, rsrc_size = 0, ref,
data_pos = 0, rsrc_pos = 0;
int err, siz, len;
struct SOCKADDR_IN lsaddr;
struct htxf_conn *htxf;
u_int16_t i;
#if defined(CONFIG_HTXF_QUEUE)
u_int16_t queue_pos;
#endif
dir[0] = 0;
if (htlc->nr_gets >= htlc->get_limit) {
for (i = 0; i < HTXF_GET_MAX; i++) {
htxf = htlc->htxf_out[i];
if (!htxf)
continue;
if ((htxf->total_pos == htxf->total_size)
|| htxf->gone)
goto ok;
}
len = snprintf(buf, sizeof(buf), "%u at a time", htlc->get_limit);
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, len, buf);
return;
}
ok:
#if defined(CONFIG_HTXF_QUEUE)
if (!htlc->access_extra.ignore_queue && nr_queued >= hxd_cfg.limits.queue_size) {
#else
if (nr_gets >= hxd_cfg.limits.total_downloads) {
#endif
#if defined(CONFIG_HTXF_QUEUE)
len = snprintf(buf, sizeof(buf),
"queue is full (%u >= %d) please try again later",
nr_gets, hxd_cfg.limits.queue_size);
#else
len = snprintf(buf, sizeof(buf),
"maximum number of total downloads reached (%u >= %d)",
nr_gets, hxd_cfg.limits.total_downloads);
#endif
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, len, buf);
return;
}
for (i = 0; i < HTXF_GET_MAX; i++)
if (!htlc->htxf_out[i])
break;
if (i == HTXF_GET_MAX) {
snd_strerror(htlc, EAGAIN);
return;
}
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_DIR:
if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) {
snd_strerror(htlc, err);
return;
}
break;
case HTLC_DATA_RFLT:
if (dh_len >= 50)
L32NTOH(data_pos, &dh_data[46]);
if (dh_len >= 66)
L32NTOH(rsrc_pos, &dh_data[62]);
break;
case HTLC_DATA_FILE_PREVIEW:
dh_getint(preview);
break;
}
dh_end()
if (!fnlen && !dir[0]) {
/* No file name given */
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
if (dir[0]) {
if (fnlen)
snprintf(path, sizeof(path), "%s/%s", dir, filename);
else
strcpy(path, dir);
} else {
snprintf(path, sizeof(path), "%s/%s", ROOTDIR, filename);
}
#ifdef HAVE_CORESERVICES
resolve_alias_path(path, path);
#endif
if (check_dropbox(htlc, path)) {
snd_strerror(htlc, EPERM);
return;
}
#ifdef CONFIG_HTXF_PREVIEW
if (preview) {
Image *img, *mimg;
ImageInfo ii;
ExceptionInfo ei;
char previewpath[MAXPATHLEN];
static int magick_inited = 0;
if (!magick_inited) {
InitializeMagick("hxd");
magick_inited = 1;
}
#if MaxTextExtent < MAXPATHLEN
if (strlen(path) >= sizeof(ii.filename)) {
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR,
13, "path too long");
return;
}
#endif
memset(&ii, 0, sizeof(ii));
memset(&ei, 0, sizeof(ei));
GetImageInfo(&ii);
GetExceptionInfo(&ei);
err = preview_path(previewpath, path, &sb);
if (!err) {
/* Preview file already exists */
strcpy(ii.filename, previewpath);
mimg = ReadImage(&ii, &ei);
} else {
/* Create preview file */
strcpy(ii.filename, path);
img = ReadImage(&ii, &ei);
if (!img)
goto text_preview;
mimg = MinifyImage(img, &ei);
DestroyImage(img);
}
if (!mimg) {
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR,
18, "MinifyImage failed");
return;
}
if (err) {
err = preview_path(previewpath, path, 0);
if (err) {
snd_strerror(htlc, err);
DestroyImage(mimg);
return;
}
strcpy(mimg->filename, previewpath);
data_pos = 0;
rsrc_pos = 0;
WriteImage(&ii, mimg);
DestroyImage(mimg);
} else {
DestroyImage(mimg);
}
strcpy(path, previewpath);
}
text_preview:
#endif
if (stat(path, &sb)) {
snd_strerror(htlc, errno);
return;
}
if (S_ISDIR(sb.st_mode)) {
snd_strerror(htlc, EISDIR);
return;
}
data_size = sb.st_size;
size = (data_size - data_pos) + (preview ? 0 : 133);
#if defined(CONFIG_HFS)
if (hxd_cfg.operation.hfs) {
rsrc_size = resource_len(path);
size += preview ? 0 : (rsrc_size - rsrc_pos);
if (!preview)
size += ((rsrc_size - rsrc_pos) ? 16 : 0) + comment_len(path);
}
#endif
ref = htxf_ref_new(htlc);
ref = htonl(ref);
siz = sizeof(struct SOCKADDR_IN);
if (getsockname(htlc->fd, (struct sockaddr *)&lsaddr, &siz)) {
hxd_log("rcv_file_get: getsockname: %s", strerror(errno));
snd_strerror(htlc, errno);
return;
}
htxf = htxf_new(htlc, 0);
htxf->type = HTXF_TYPE_FILE;
htxf->data_size = data_size;
htxf->rsrc_size = rsrc_size;
htxf->data_pos = data_pos;
htxf->rsrc_pos = rsrc_pos;
htxf->total_size = size;
htxf->ref = ref;
htxf->limit_out_Bps = htlc->nr_puts > 0 ?
(htlc->limit_uploader_out_Bps ? htlc->limit_uploader_out_Bps : htlc->limit_out_Bps) :
htlc->limit_out_Bps;
hxd_log("conf: %u!%u", htxf->limit_out_Bps, htlc->limit_out_Bps);
htxf->preview = preview;
htxf->sockaddr = htlc->sockaddr;
htxf->listen_sockaddr = lsaddr;
htxf->listen_sockaddr.SIN_PORT = htons(ntohs(htxf->listen_sockaddr.SIN_PORT) + 1);
strcpy(htxf->path, path);
htlc->nr_gets++;
nr_gets++;
#if defined(CONFIG_HTXF_QUEUE)
if (htlc->access_extra.ignore_queue)
htxf->queue_pos = queue_pos = 0;
else
htxf->queue_pos = queue_pos = insert_into_queue(htlc);
#endif
if (log_download) {
inaddr2str(abuf, &htlc->sockaddr);
hxd_log("%s@%s:%u - %s:%u:%u:%s - download %s:%08x", htlc->userid, abuf, ntohs(htlc->sockaddr.SIN_PORT),
htlc->name, htlc->icon, htlc->uid, htlc->login, htxf->path, htxf->ref);
#if defined(CONFIG_SQL)
sql_download(htlc->name, abuf, htlc->login, path);
#endif
}
size = htonl(size);
#if defined(CONFIG_HTXF_QUEUE)
queue_pos = htons(queue_pos);
hlwrite(htlc, HTLS_HDR_TASK, 0, 3,
HTLS_DATA_HTXF_REF, sizeof(ref), &ref,
HTLS_DATA_HTXF_SIZE, sizeof(size), &size,
HTLS_DATA_QUEUE_POSITION, sizeof(queue_pos), &queue_pos);
#else
hlwrite(htlc, HTLS_HDR_TASK, 0, 2,
HTLS_DATA_HTXF_REF, sizeof(ref), &ref,
HTLS_DATA_HTXF_SIZE, sizeof(size), &size);
#endif
}
void
rcv_file_put (struct htlc_conn *htlc)
{
u_int16_t fnlen = 0, resume = 0;
char path[MAXPATHLEN], dir[MAXPATHLEN], filename[NAME_MAX];
char abuf[HOSTLEN+1], buf[128];
struct stat sb;
int err, siz, len;
u_int32_t ref, data_pos = 0, rsrc_pos = 0, totalsize = 0;
u_int8_t rflt[74];
struct SOCKADDR_IN lsaddr;
struct htxf_conn *htxf;
u_int16_t i;
dir[0] = 0;
if (htlc->nr_puts >= htlc->put_limit) {
len = snprintf(buf, sizeof(buf), "%u at a time", htlc->put_limit);
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, len, buf);
return;
}
if (nr_puts >= hxd_cfg.limits.total_uploads) {
len = snprintf(buf, sizeof(buf), "maximum number of total uploads reached (%u >= %d)",
nr_gets, hxd_cfg.limits.total_uploads);
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, len, buf);
return;
}
for (i = 0; i < HTXF_PUT_MAX; i++)
if (!htlc->htxf_in[i])
break;
if (i == HTXF_PUT_MAX) {
snd_strerror(htlc, EAGAIN);
return;
}
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_DIR:
if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) {
snd_strerror(htlc, err);
return;
}
break;
case HTLC_DATA_FILE_PREVIEW:
dh_getint(resume);
break;
case HTLC_DATA_HTXF_SIZE:
dh_getint(totalsize);
break;
}
dh_end()
if (!htlc->access.upload_anywhere && (!dir[0] || (!strcasestr(dir, "UPLOAD") && !strcasestr(dir, "DROP BOX")))) {
snd_strerror(htlc, EPERM);
return;
}
if (!fnlen && !dir[0]) {
/* No file name given */
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
if (dir[0]) {
if (fnlen)
snprintf(path, sizeof(path), "%s/%s", dir, filename);
else
strcpy(path, dir);
} else {
snprintf(path, sizeof(path), "%s/%s", ROOTDIR, filename);
}
#ifdef HAVE_CORESERVICES
resolve_alias_path(path, path);
#endif
if (!resume) {
if (!stat(path, &sb)) {
snd_strerror(htlc, EEXIST);
return;
}
if (errno != ENOENT) {
snd_strerror(htlc, errno);
return;
}
} else {
if (stat(path, &sb)) {
snd_strerror(htlc, errno);
return;
}
data_pos = sb.st_size;
#if defined(CONFIG_HFS)
if (hxd_cfg.operation.hfs)
rsrc_pos = resource_len(path);
#endif
memcpy(rflt, "RFLT\0\1\
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
\0\0\0\2DATA\0\0\0\0\0\0\0\0\0\0\0\0MACR\0\0\0\0\0\0\0\0\0\0\0\0", 74);
S32HTON(data_pos, &rflt[46]);
S32HTON(rsrc_pos, &rflt[62]);
}
ref = htxf_ref_new(htlc);
ref = htonl(ref);
siz = sizeof(struct SOCKADDR_IN);
if (getsockname(htlc->fd, (struct sockaddr *)&lsaddr, &siz)) {
hxd_log("rcv_file_get: getsockname: %s", strerror(errno));
snd_strerror(htlc, errno);
return;
}
htxf = htxf_new(htlc, 1);
htxf->type = HTXF_TYPE_FILE;
htxf->data_pos = data_pos;
htxf->rsrc_pos = rsrc_pos;
htxf->total_size = totalsize;
htxf->ref = ref;
htxf->sockaddr = htlc->sockaddr;
htxf->listen_sockaddr = lsaddr;
htxf->listen_sockaddr.SIN_PORT = htons(ntohs(htxf->listen_sockaddr.SIN_PORT) + 1);
strcpy(htxf->path, path);
htlc->nr_puts++;
nr_puts++;
if (log_upload) {
inaddr2str(abuf, &htlc->sockaddr);
hxd_log("%s@%s:%u - %s:%u:%u:%s - upload %s:%08x", htlc->userid, abuf, ntohs(htlc->sockaddr.SIN_PORT),
htlc->name, htlc->icon, htlc->uid, htlc->login, htxf->path, htxf->ref);
#if defined(CONFIG_SQL)
sql_upload(htlc->name, abuf, htlc->login, path);
#endif
}
if (!resume)
hlwrite(htlc, HTLS_HDR_TASK, 0, 1,
HTLS_DATA_HTXF_REF, sizeof(ref), &ref);
else
hlwrite(htlc, HTLS_HDR_TASK, 0, 2,
HTLS_DATA_RFLT, 74, rflt,
HTLS_DATA_HTXF_REF, sizeof(ref), &ref);
}
void
rcv_folder_get (struct htlc_conn *htlc)
{
u_int16_t fnlen = 0, preview = 0;
char path[MAXPATHLEN], dir[MAXPATHLEN], filename[NAME_MAX], pathbuf[MAXPATHLEN];
char abuf[HOSTLEN+1], buf[128];
struct stat sb;
u_int32_t size = 0, data_size = 0, rsrc_size = 0, ref,
data_pos = 0, rsrc_pos = 0, nfiles = 0;
int err, siz, len;
struct SOCKADDR_IN lsaddr;
struct htxf_conn *htxf;
u_int16_t i;
DIR *dirp;
struct dirent *de;
dir[0] = 0;
if (htlc->nr_gets >= htlc->get_limit) {
len = snprintf(buf, sizeof(buf), "%u at a time", htlc->get_limit);
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, len, buf);
return;
}
if (nr_gets >= hxd_cfg.limits.total_downloads) {
len = snprintf(buf, sizeof(buf), "maximum number of total downloads reached (%u >= %d)",
nr_gets, hxd_cfg.limits.total_downloads);
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, len, buf);
return;
}
for (i = 0; i < HTXF_GET_MAX; i++)
if (!htlc->htxf_out[i])
break;
if (i == HTXF_GET_MAX) {
snd_strerror(htlc, EAGAIN);
return;
}
dh_start(htlc)
switch (dh_type) {
case HTLC_DATA_FILE_NAME:
fnlen = dh_len >= NAME_MAX ? NAME_MAX - 1 : dh_len;
read_filename(filename, dh_data, fnlen);
break;
case HTLC_DATA_DIR:
if ((err = hldir_to_path(dh, ROOTDIR, dir, dir))) {
snd_strerror(htlc, err);
return;
}
break;
case HTLC_DATA_RFLT:
if (dh_len >= 50)
L32NTOH(data_pos, &dh_data[46]);
if (dh_len >= 66)
L32NTOH(rsrc_pos, &dh_data[62]);
break;
case HTLC_DATA_FILE_PREVIEW:
dh_getint(preview);
break;
}
dh_end()
if (!fnlen && !dir[0]) {
/* No file name given */
hlwrite(htlc, HTLS_HDR_TASK, 1, 1, HTLS_DATA_TASKERROR, 6, "huh?!?");
return;
}
if (dir[0]) {
if (fnlen)
snprintf(path, sizeof(path), "%s/%s", dir, filename);
else
strcpy(path, dir);
} else {
snprintf(path, sizeof(path), "%s/%s", ROOTDIR, filename);
}
#ifdef HAVE_CORESERVICES
resolve_alias_path(path, path);
#endif
if (check_dropbox(htlc, path)) {
snd_strerror(htlc, EPERM);
return;
}
if (stat(path, &sb)) {
snd_strerror(htlc, errno);
return;
}
if (!S_ISDIR(sb.st_mode)) {
snd_strerror(htlc, ENOTDIR);
return;
}
if (!(dirp = opendir(path))) {
snd_strerror(htlc, errno);
return;
}
while ((de = readdir(dirp))) {
if (de->d_name[0] == '.')
continue;
nfiles++;
snprintf(pathbuf, sizeof(pathbuf), "%s/%s", path, de->d_name);
if (stat(pathbuf, &sb))
continue;
if (S_ISDIR(sb.st_mode))
continue;
data_size = sb.st_size;
rsrc_size = resource_len(pathbuf);
size += (data_size - data_pos) + (preview ? 0 : (rsrc_size - rsrc_pos));
size += 133 + ((rsrc_size - rsrc_pos) ? 16 : 0) + comment_len(pathbuf);
}
closedir(dirp);
if (!nfiles) {
hlwrite(htlc, HTLS_HDR_TASK, 0, 2,
HTLC_DATA_HTXF_SIZE, sizeof(size), &size,
HTLC_DATA_FILE_NFILES, sizeof(nfiles), &nfiles);
return;
}
ref = htxf_ref_new(htlc);
ref = htonl(ref);
siz = sizeof(struct SOCKADDR_IN);
if (getsockname(htlc->fd, (struct sockaddr *)&lsaddr, &siz)) {
hxd_log("rcv_file_get: getsockname: %s", strerror(errno));
snd_strerror(htlc, errno);
return;
}
htxf = htxf_new(htlc, 0);
htxf->type = HTXF_TYPE_FOLDER;
htxf->total_size = size;
htxf->ref = ref;
htxf->preview = preview;
htxf->sockaddr = htlc->sockaddr;
htxf->listen_sockaddr = lsaddr;
htxf->listen_sockaddr.SIN_PORT = htons(ntohs(htxf->listen_sockaddr.SIN_PORT) + 1);
strcpy(htxf->path, path);
htlc->nr_gets++;
nr_gets++;
if (log_download) {
inaddr2str(abuf, &htlc->sockaddr);
hxd_log("%s@%s:%u - %s:%u:%u:%s - download %s:%08x", htlc->userid, abuf, ntohs(htlc->sockaddr.SIN_PORT),
htlc->name, htlc->icon, htlc->uid, htlc->login, htxf->path, htxf->ref);
}
size = htonl(size);
nfiles = htonl(nfiles);
hlwrite(htlc, HTLS_HDR_TASK, 0, 3,
HTLS_DATA_HTXF_SIZE, sizeof(size), &size,
HTLS_DATA_FILE_NFILES, sizeof(nfiles), &nfiles,
HTLS_DATA_HTXF_REF, sizeof(ref), &ref);
}
void opt_d(int argc, char **argv,int *arch, int *filecount, int *fcalled, file *info){
int fbyte_max=1;
int fbyte=0;
int size = 0;
int tsize = 0;
int tempfile=0;
int temparch =0;
char cur_name[16];
char *null_cur_name;
char *null_info_name;
char *str_buf;
struct stat archinfo;
struct stat temparch_info;
fstat((*arch),&archinfo);
temparch = open_file("temp_arch",1);
fbyte_max = archinfo.st_size;
//for fcalled goes here
fbyte = 0;
lseek((*arch),8,SEEK_SET);
read_filename(argv,filecount,4,fcalled,info);
for(fbyte=0; fbyte < fbyte_max; ){
read((*arch),cur_name,16);
null_cur_name = null_str(cur_name,16);
null_cur_name = shrt_str(null_cur_name);
null_info_name= null_str(info->name,16);
null_info_name = shrt_str(null_info_name);
(fbyte) += 60+atoi(info->size);
if(fbyte < fbyte_max){
if(!strcmp(null_cur_name,null_info_name)){//equal
iter_arch((*arch), &fbyte, info);
(fbyte) -= 60+atoi(info->size);
}else{
tempfile = 0;
put_header((*arch), info);
lseek((*arch),2,SEEK_CUR);
/*printf("\ninfo->name: %.16s\n",info->name);
printf("cur name: %.16s\n",cur_name);
printf("info->time: %.12s\n",info->time);
printf("info->uid: %.6s\n",info->uid);
printf("info->gid: %.6s\n",info->gid);
printf("info->mode: %.8s\n",info->mode);
printf("info->size: %.10s\n",info->size);
*/
//so now the header are read correctly
//Time to put info in files
tempfile = create_tempfile();
write_file_header2(tempfile,cur_name,info);
info->desc = (*arch);
write_file_content(tempfile,info);
all_in_arch(tempfile,temparch,fcalled,info);
if(tsize%2!=0){
write(temparch,"\n",1);
}
(*fcalled)++;
close(tempfile);
if(atoi(info->size)%2!=0)
lseek((*arch),1,SEEK_CUR);
}
}
}
//FIXME: the temp_arch has the correct info but when copy to arch itself has wrong info.
fstat(temparch,&temparch_info);
size = temparch_info.st_size;
printf("temparch.size: %d\n",size);
str_buf = malloc(sizeof(char)*size);
read(temparch,str_buf,size);
//ftruncate((*arch),(sizeof(char))*size);
lseek((*arch),0,SEEK_SET);
write((*arch),str_buf,size);
free(str_buf);
close(temparch);
//remove("temp_arch");
}
void opt_d(int argc, char **argv,int *arch, int *filecount, int *fcalled, file *info){
int fbyte_max=1;
int fbyte=0;
int size = 0;
int tempfile=0;
int temparch =0;
char cur_name[16];
char *null_cur_name;
char *null_info_name;
char *str_buf;
struct stat archinfo;
struct stat temparch_info;
fstat((*arch),&archinfo);
temparch = create_tempfile();
write(temparch,"!<arch>\n",8);
fstat(temparch,&temparch_info);
fbyte_max = archinfo.st_size;
fbyte = 0;
lseek((*arch),8,SEEK_SET);
read_filename(argv,filecount,4,fcalled,info);
for(fbyte=0; fbyte < fbyte_max; fbyte++){
read((*arch),cur_name,16);
null_cur_name = null_str(cur_name,16);
null_cur_name = shrt_str(null_cur_name);
null_info_name= null_str(info->name,16);
null_info_name = shrt_str(null_info_name);
(fbyte) += 60+atoi(info->size);
if(fbyte < fbyte_max){
if(!strcmp(null_cur_name,null_info_name)){
iter_arch((*arch), &fbyte, info);
if(atoi(info->size)%2!=0){
lseek((*arch),1,SEEK_CUR);
(fbyte)++;
}
}else{
read_header(argc, argv, filecount, 4, fcalled, info);
tempfile = create_tempfile();
write_file_header(tempfile,info);
info->desc = (*arch);
write_file_content(tempfile,info);
all_in_arch(tempfile,temparch,fcalled,info);
close(tempfile);
}
}
}
remove(argv[1]);
(*arch) = open_file(argv[1],1);
size = temparch_info.st_size;
str_buf = malloc(sizeof(char)*size);
read(temparch,str_buf,size);
close(temparch);
}
