Пример #1
0
static void read_client_file_line(FILE *file, struct file *f) {

    if (fscanf(file, "%s\n", f->name) != 1 || !validate_file(f, false)) {

        cvs_error(CORRUPT_REPO_ERROR);
    }
}
Пример #2
0
/******************************************************************************
* subroutine: serve_head                                                      *
* purpose:    return response header to client                                *
* parameters: client_fd - client descriptor                                   *
*             context   - a pointer refers to HTTP context                    *
*             is_closed - an indicator if the current transaction is closed   *
* return:     none                                                            *
******************************************************************************/
void serve_head(int client_fd, HTTPContext *context, int *is_closed)
{
    struct tm tm;
    struct stat sbuf;
    time_t now;
    char   buf[BUF_SIZE], filetype[MIN_LINE], tbuf[MIN_LINE], dbuf[MIN_LINE]; 

    if (validate_file(client_fd, context, is_closed) < 0) return;

    stat(context->filename, &sbuf);
    get_filetype(context->filename, filetype);

    // get time string
    tm = *gmtime(&sbuf.st_mtime);
    strftime(tbuf, MIN_LINE, "%a, %d %b %Y %H:%M:%S %Z", &tm);
    now = time(0);
    tm = *gmtime(&now);
    strftime(dbuf, MIN_LINE, "%a, %d %b %Y %H:%M:%S %Z", &tm);

    // send response headers to client
    sprintf(buf, "HTTP/1.1 200 OK\r\n");
    sprintf(buf, "%sDate: %s\r\n", buf, dbuf);
    sprintf(buf, "%sServer: Liso/1.0\r\n", buf);
    if (is_closed) sprintf(buf, "%sConnection: close\r\n", buf);
    sprintf(buf, "%sContent-Length: %ld\r\n", buf, sbuf.st_size);
    sprintf(buf, "%sContent-Type: %s\r\n", buf, filetype);
    sprintf(buf, "%sLast-Modified: %s\r\n\r\n", buf, tbuf);
    send(client_fd, buf, strlen(buf), 0);
}
Пример #3
0
static void read_server_file_line(FILE *file, struct file *f) {

    if (fscanf(file, "%s %d %d\n", f->name, &f->version, &f->id) != 3 || !validate_file(f, true)) {

        cvs_error(CORRUPT_REPO_ERROR);
    }
}
Пример #4
0
// XXX: need comment here
static int do_init_reg(cr_location_t *loc, struct file *filp)
{
	int result;

	result = validate_file(filp, loc->is_write);
	if (!result) {
	    loc->filp = filp;
	    init_MUTEX(&loc->mutex);
	}

	return result;
}
Пример #5
0
// cr_loc_get(loc, shared)
//
// Returns the filp to write to.
// Sets 'shared' to indicate if the file is shared with other threads.
// If so, then the caller is responsible for any synchronization.
// The loc->mutex field is provided for this purpose.
//
struct file *cr_loc_get(cr_location_t *loc, int *shared)
{
	struct file *filp = NULL;

	if (loc->filp) {
		// Destination is a "regular" file.

		// Just return the filp.  We don't need to fget()
		// because the fget() done in cr_loc_init is sufficient.
		filp = loc->filp;

		if (shared) {
			*shared = 1;
		}
	} else if (loc->fs) {
		// Destination is a per-process file in a given directory.

		struct fs_struct *saved_fs;
		char filename[CR_FILE_MAX];
		int error;

		// Create a filename
		sprintf(filename, CR_FILE_PATT, current->pid);

		// Play with current->fs to open() in the destination dir
		saved_fs = current->fs;
		current->fs = loc->fs;
		filp = filp_open(filename,
				 O_NOFOLLOW | (loc->is_write ? (O_WRONLY | O_CREAT | O_TRUNC) : O_RDONLY),
				 CR_FILE_MODE);
		current->fs = saved_fs;

		error = validate_file(filp, loc->is_write);
		if (error) {
			filp = ERR_PTR(error);
		}

		if (shared) {
			*shared = 0;
		}
	}

	return filp;
}
Пример #6
0
static bool validate_modification(struct modification *m, bool server) {

    if (!validate_file(&m->file, server))
        return false;

    if (!m->action || !strchr("ADMN", m->action))
        return false;

    if (m->action == MOVE) {

        m->new_name[MAX_PATH_LENGTH - 1] = 0;

        int length = strlen(m->new_name);

        if (length == 0 || length == MAX_PATH_LENGTH -1)
            return false;
    }

    return true;
}
Пример #7
0
static void iterate_files(const char *path, const long *files,
	long start_at, long end_at, int progress)
{
	uint64_t tot_ok, tot_corrupted, tot_changed, tot_overwritten, tot_size;
	struct timeval tot_dt = { .tv_sec = 0, .tv_usec = 0 };
	double read_speed;
	const char *unit;
	int and_read_all = 1;
	int or_missing_file = 0;
	int number = start_at;

	tot_ok = tot_corrupted = tot_changed = tot_overwritten = tot_size = 0;
	printf("                  SECTORS "
		"     ok/corrupted/changed/overwritten\n");

	while (*files >= 0) {
		uint64_t sec_ok, sec_corrupted, sec_changed,
			sec_overwritten, file_size;
		int read_all;

		or_missing_file = or_missing_file || (*files != number);
		for (; number < *files; number++) {
			char *full_fn;
			const char *filename;
			full_fn = full_fn_from_number(&filename, "", number);
			assert(full_fn);
			printf("Missing file %s\n", filename);
			free(full_fn);
		}
		number++;

		validate_file(path, *files, &sec_ok, &sec_corrupted,
			&sec_changed, &sec_overwritten,
			&file_size, &read_all, &tot_dt, progress);
		tot_ok += sec_ok;
		tot_corrupted += sec_corrupted;
		tot_changed += sec_changed;
		tot_overwritten += sec_overwritten;
		tot_size += file_size;
		and_read_all = and_read_all && read_all;
		files++;
	}
	assert(tot_size / SECTOR_SIZE ==
		(tot_ok + tot_corrupted + tot_changed + tot_overwritten));

	/* Notice that not reporting `missing' files after the last file
	 * in @files is important since @end_at could be very large.
	 */

	report("\n  Data OK:", tot_ok);
	report("Data LOST:", tot_corrupted + tot_changed + tot_overwritten);
	report("\t       Corrupted:", tot_corrupted);
	report("\tSlightly changed:", tot_changed);
	report("\t     Overwritten:", tot_overwritten);
	if (or_missing_file)
		printf("WARNING: Not all F3 files in the range %li to %li are available\n",
			start_at + 1, end_at + 1);
	if (!and_read_all)
		printf("WARNING: Not all data was read due to I/O error(s)\n");

	/* Reading speed. */
	read_speed = (double)tot_size / dt_to_s(&tot_dt);
	unit = adjust_unit(&read_speed);
	printf("Average reading speed: %.2f %s/s\n", read_speed, unit);
}

int main(int argc, char **argv)
{
	const long *files;

	struct args args = {
		/* Defaults. */
		.start_at	= 0,
		.end_at		= LONG_MAX - 1,
		/* If stdout isn't a terminal, supress progress. */
		.show_progress	= isatty(STDOUT_FILENO),
	};

	/* Read parameters. */
	argp_parse(&argp, argc, argv, 0, NULL, &args);
	print_header(stdout, "read");

	files = ls_my_files(args.dev_path, args.start_at, args.end_at);

	iterate_files(args.dev_path, files, args.start_at, args.end_at,
		args.show_progress);
	free((void *)files);
	return 0;
}
int main(int argc, char *argv[])
{
	int rc, option = 0, result = 0, priority = 0, flagk = 0, flage = 0;
	int flagd = 0, flaga = 0, flagh = 0, flagc = 0, flagz = 0, flagu =
	    0;
	int count =1;
	int flagr = 0, flagR = 0, flagl = 0, flagC = 0, job_id = 0;
	char *algo = NULL, *key = NULL, *infile = NULL, *outfile = NULL;
	void *dummy = NULL;
	struct job my_job;
	unsigned char *digest = NULL;
	MD5_CTX md5;
	MD5_Init(&md5);

	while ((option = getopt(argc, argv, "edk:a:hiczur:RlC")) != -1) {
		switch (option) {
		case 'e':
			flage++;
			my_job.job_type = ENCRYPT;
			break;
		case 'd':
			flagd++;
			my_job.job_type = DECRYPT;
			break;
		case 'k':
			flagk++;
			key = optarg;
			if (strlen(key) < 6) {
				printf
				    ("Key length should be minimum 6 characters.\n");
				rc = -EINVAL;
				goto out;
			}
			break;
		case 'a':
			flaga++;
			algo = optarg;
			break;
		case 'h':
			flagh++;
			my_job.job_type = CHECKSUM;
			break;
		case 'c':
			flagc++;
			my_job.job_type = CONCAT;
			break;
		case 'z':
			flagz++;
			my_job.job_type = COMPRESS;
			break;
		case 'u':
			flagu++;
			my_job.job_type = DECOMPRESS;
			break;
		case 'r':
			flagr++;
			job_id = atoi(optarg);
			my_job.job_type = REMOVE;
			break;
		case 'R':
			flagR++;
			printf("remove all jobs\n");
			my_job.job_type = REMOVEALL;
			break;
		case 'l':
			flagl++;
			my_job.job_type = DISPLAY;
			break;
		case 'C':
			flagC++;
			my_job.job_type = CHANGEPR;
			break;
		default:
			printf("Invalid option.\n");
			goto out;
		}
	}
	if (flage && (flagd || flagc || flagh || flagz || flagu ||
		      flagr || flagR || flagl)) {
		printf("error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flage > 1) {
		printf("Error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagd && (flage || flagc || flagh || flagz || flagu ||
		      flagr || flagR || flagl)) {
		printf("error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagd > 1) {
		printf("Error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (!flagk && (flage || flagd)) {
		printf("Please provide key.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flaga && (flagc || flagz || flagu || flagr || flagR || flagl)) {
		printf("error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (!flaga) {
		if ((flage) || (flagd)) {
			algo = "AES";
		} else {
			algo = "MD5";
		}
	}
	if (flagc && (flagd || flage || flagh || flagz || flagu ||
		      flagr || flagR || flagl)) {
		printf("error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagc > 1) {
		printf("Error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagh && (flagd || flagc || flage || flagz || flagu ||
		      flagr || flagR || flagl)) {
		printf("error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagh > 1) {
		printf("Error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagz && (flagd || flagc || flagh || flage || flagu ||
		      flagr || flagR || flagl)) {
		printf("error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagz > 1) {
		printf("Error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagu && (flagd || flagc || flagh || flagz || flage ||
		      flagr || flagR || flagl)) {
		printf("error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagu > 1) {
		printf("Error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagr > 1) {
		printf("Error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagR > 1) {
		printf("Error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagl > 1) {
		printf("Error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagC > 1) {
		printf("Error in parameters passed.\n");
		rc = -EINVAL;
		goto out;
	}
	if (flagr)
		goto out_hash;
	if (flagR)
		goto out_hash;
	if (flagl) {
		goto out_hash;
	}
	if (flagC) {
		if (!argv[optind]) {
			printf("Please provide job id.\n");
			goto out;
		}
		my_job.job_id = atoi(argv[optind]);
		if (!argv[optind + 1]) {
			printf("Please provide job priority.\n");
			goto out;
		}
		my_job.priority = atoi(argv[optind + 1]);
		goto out_hash;
	}
	if (!argv[optind]) {
		printf("Please provide priority of job.\n");
		goto out;
	}
	my_job.job_id = 0;
	priority = atoi(argv[optind]);
	my_job.priority = priority;
	if (!argv[optind + 1]) {
		printf("Please provide input file.\n");
		goto out;
	}
	infile = argv[optind + 1];
	result = validate_file(infile);
	if (result == -1)
		goto out;
	my_job.infile = infile;
	if (argv[optind + 2]) {
		if (flagh) {
                        printf("Output file not needed.\n");
                        goto out;
                }
	}
	else if (!argv[optind + 2] && !flagh) {
		printf("Please provide output file.\n");
		goto out;
	}
	outfile = argv[optind + 2];
out_hash:
	my_job.pid = getpid();
	if (my_job.job_type == ENCRYPT || my_job.job_type == DECRYPT) {
		my_job.outfile = outfile;
		my_job.algo = algo;
		digest = malloc(sizeof(unsigned char) * 16);
		if (!digest)
			goto out;
		MD5_Update(&md5, key, 16);
		MD5_Final(digest, &md5);
		my_job.key = digest;
	}
	if (my_job.job_type == CHECKSUM) {
		my_job.algo = algo;
		my_job.outfile = NULL;
		my_job.key = NULL;
	}
	if (my_job.job_type == CONCAT || my_job.job_type == COMPRESS
	    || my_job.job_type == DECOMPRESS) {
		my_job.outfile = outfile;
		my_job.key = NULL;
		my_job.algo = NULL;
	}
	if (my_job.job_type == DISPLAY) {
		my_job.outfile = malloc(PAGE_SIZE * 2);
		my_job.infile = NULL;
		my_job.algo = NULL;
		my_job.key = NULL;
		goto sys_call_returned;
	}
	if (my_job.job_type == REMOVEALL) {
		my_job.infile = NULL;
		my_job.outfile = NULL;
		my_job.algo = NULL;
		my_job.key = NULL;
		goto sys_call_returned;
	}
	if (my_job.job_type == REMOVE) {
		my_job.job_id = job_id;
		my_job.infile = NULL;
		my_job.outfile = NULL;
		my_job.algo = NULL;
		my_job.key = NULL;
		goto sys_call_returned;
	}
	if (my_job.job_type == CHANGEPR) {
		my_job.infile = NULL;
		my_job.outfile = NULL;
		my_job.algo = NULL;
		my_job.key = NULL;
		goto sys_call_returned;
	}
	skt_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_USER);

	if (flagh || flage || flagd || flagc || flagz || flagu) {
		if (pthread_create
		    (&th1, NULL, (void *) &netlink_skt, (void *) skt_fd)) {
			printf("Error in thread creation\n");
		} else
			printf("Thread Created\n");
	}
sys_call_returned:
	dummy = (void *) &my_job;
	rc = syscall(__NR_submitjob, dummy);
	if (rc == 0) {
		if (flagl) {
			printf("Job_id\t Job_Priority Job Type\tInput File\n");
			printf("%s", my_job.outfile);
			goto out;
		}
		if (flagR) {
			printf("All jobs deleted.\n");
			goto out;
		}
		if (flagr) {
			printf("Job deleted.\n");
			goto out;
		}
		if (flagC) {
			printf("Job priority changed.\n");
			goto out;
		}
		printf("syscall returned %d\n", rc);

	} else {
		if (flagl) {
			printf("Error while listing jobs.\n");
			goto out_err2;
		}
		if (flagR) {
			printf("Error while deleting jobs.\n");
			goto out_err2;
		}
		if (flagr) {
			printf("Job with job id %d doesn't exist.\n",
			       my_job.job_id);
			goto out_err2;
		}
out_err2:
		printf("syscall returned %d (errno=%d)\n", rc, errno);
		perror("Error");
		goto out;
	}

	printf("count = %d\n",++count);
	if (pthread_join(th1, NULL)) {
		printf("Error joining thread\n");
	}

	printf("count = %d\n",++count);
out:
	if (my_job.outfile && flagl)
		free(my_job.outfile);
	if (digest)
		free(digest);
	exit(rc);
}
Пример #9
0
int cvsrename(int argc, char **argv)
{
    int c;
    int err = 0;
	char *repos_file1, *repos_file2;
	char *root1, *root2;
	const char *filename1, *filename2, *dir1, *dir2;
	int rootlen;
	List *ent,*ent2;
	Node *node;
	Entnode *entnode;
	const char *cwd;

	if (argc == -1)
		usage (rename_usage);

	quiet = 0;

    optind = 0;
    while ((c = getopt (argc, argv, "+q")) != -1)
    {
	switch (c)
	{
	case 'q':
		quiet = 1;
		break;
    case '?':
    default:
		usage (rename_usage);
		break;
	}
    }
    argc -= optind;
    argv += optind;

	if(argc!=2)
	{
		usage(rename_usage);
	};

	error(0,0,"Warning: rename is still experimental and may not behave as you would expect");

	if(current_parsed_root->isremote)
	{
		if(!supported_request("Rename"))
			error(1,0,"Remote server does not support rename");
		if(!supported_request("Can-Rename"))
			error(1,0,"Renames are currently disabled");
	}

	if(!strcmp(argv[0],argv[1]))
		return 0;

	rootlen = strlen(current_parsed_root->directory);

	if(!isfile(argv[0]))
		error(1,0,"%s does not exist",argv[0]);

	if(isfile(argv[1]) && fncmp(argv[0],argv[1])) /* We allow case renames (on Unix this is redundant) */
		error(1,0,"%s already exists",argv[1]);

	if(isdir(argv[0]))
		error(1,0,"Directory renames are not currently supported");

	validate_file(argv[0],&root1, &repos_file1, &filename1, &dir1, 1);
	validate_file(argv[1],&root2, &repos_file2, &filename2, &dir2, 0);

	if(strcmp(root1,root2) || strcmp(root1,current_parsed_root->original))
		error(1,0,"%s and %s are in different repositories",argv[0],argv[1]);

	xfree(root1);
	xfree(root2);

	repos_file1 = (char*)xrealloc(repos_file1, strlen(filename1)+strlen(repos_file1)+rootlen+10);
	repos_file2 = (char*)xrealloc(repos_file2, strlen(filename2)+strlen(repos_file2)+rootlen+10);
	memmove(repos_file1+rootlen+1,repos_file1,strlen(repos_file1)+1);
	memmove(repos_file2+rootlen+1,repos_file2,strlen(repos_file2)+1);
	strcpy(repos_file1,current_parsed_root->directory);
	strcpy(repos_file2,current_parsed_root->directory);
	repos_file1[rootlen]='/';
	repos_file2[rootlen]='/';
	strcat(repos_file1,"/");
	strcat(repos_file2,"/");
	strcat(repos_file1,filename1);
	strcat(repos_file2,filename2);

	if(fncmp(argv[0],argv[1]))
		set_mapping(dir2,repos_file2+rootlen+1,""); /* Delete old file */
	if(fncmp(dir1,dir2))
		set_mapping(dir1,repos_file1+rootlen+1,""); 
	set_mapping(dir2,repos_file1+rootlen+1,repos_file2+rootlen+1); /* Rename to new file */

	cwd = xgetwd();
	if(CVS_CHDIR(dir1))
		error(1,errno,"Couldn't chdir to %s",dir1);
	ent = Entries_Open(0, NULL);
	node = findnode_fn(ent, filename1);
	entnode=(Entnode*)node->data;

	if(!node)
	{
		error(1,0,"%s is not listed in CVS/Entries",filename1);
		CVS_CHDIR(cwd);
		xfree(cwd);
		return 1;
	}

	if(!fncmp(dir1,dir2))
		Rename_Entry(ent,filename1,filename2);
	else
	{
		if(CVS_CHDIR(cwd))
			error(1,errno,"Couldn't chdir to %s",cwd);
		if(CVS_CHDIR(dir2))
			error(1,errno,"Couldn't chdir to %s",dir2);
		ent2 = Entries_Open(0, NULL);
		if(entnode->type==ENT_FILE)
			Register(ent2,(char*)filename2,entnode->version,entnode->timestamp,entnode->options,entnode->tag,entnode->date,entnode->conflict,entnode->merge_from_tag_1,entnode->merge_from_tag_2,entnode->rcs_timestamp,entnode->edit_revision,entnode->edit_tag,entnode->edit_bugid,entnode->md5);
		else if(entnode->type==ENT_SUBDIR)
			Subdir_Register(ent2,NULL,filename2);
		else
			error(1,0,"Unknown entry type %d in entries file",node->type);

		Entries_Close(ent2);
		if(CVS_CHDIR(cwd))
			error(1,errno,"Couldn't chdir to %s",cwd);
		if(CVS_CHDIR(dir1))
			error(1,errno,"Couldn't chdir to %s",dir1);

		if(entnode->type==ENT_SUBDIR)
			Subdir_Deregister(ent,NULL,filename1);
		else if(entnode->type==ENT_FILE)
			Scratch_Entry(ent,filename1);
		else
			error(1,0,"Unknown entry type %d in entries file",node->type);
	}
	Entries_Close(ent);

	CVS_RENAME(argv[0],argv[1]);

	if(isdir(argv[1]))
	{
		char *tmp=(char*)xmalloc(strlen(argv[1])+strlen(CVSADM_VIRTREPOS)+10);
		FILE *fp;
		sprintf(tmp,"%s/%s",argv[1],CVSADM_VIRTREPOS);
		fp = fopen(tmp,"w");
		if(!fp)
			error(0,errno,"Couldn't write %s",tmp);
		fprintf(fp,"%s\n",repos_file2+rootlen+1);
		fclose(fp);
	}

	xfree(repos_file1);
	xfree(repos_file2);
	xfree(dir1);
	xfree(dir2);
	CVS_CHDIR(cwd);
	xfree(cwd);

    return (err);
}
Пример #10
0
uint8_t _main_flight(json_t *data) {
    json_t *_source, *_destination, *_set_start, *_set_end, *_pilot, *_task;
    const char *source;
    char *destination, *pilot;
    size_t set_start, set_end;

    _source = json_object_get(data, "source");
    _destination = json_object_get(data, "destination");
    _set_start = json_object_get(data, "set_start");
    _set_end = json_object_get(data, "set_end");
    _pilot = json_object_get(data, "pilot");
    _task = json_object_get(data, "task");

    if (!json_is_string(_source)) {
        fprintf(stderr, "{\"error\": \"No source file provided\"}");
        return 0;
    }

    source = json_string_value(_source);

    if (!json_is_string(_destination)) {
        destination = calloc(strlen(source) + 1, sizeof(char));
        strcpy(destination, source);
        dirname(destination);
    } else {
        destination = (char *) json_string_value(_destination);
    }

    if (!json_is_string(_pilot)) {
        pilot = (char *) json_string_value(_pilot);
    }

    char out_file_1[strlen(destination) + 20];
    char out_file_2[strlen(destination) + 20];
    char out_file_3[strlen(destination) + 20];
    char out_file_4[strlen(destination) + 20];
    sprintf(out_file_1, "%s%s", destination, "/track.js");
    sprintf(out_file_2, "%s%s", destination, "/track.kml");
    sprintf(out_file_3, "%s%s", destination, "/track_earth.kml");
    sprintf(out_file_4, "%s%s", destination, "/track_split.kml");

    char *igc_file = load_file(source);
    if (igc_file != NULL) {
        coordinate_set_t *set = NEW(coordinate_set_t, 1);
        coordinate_set_init(set);

        task_t *read_task = NULL;
        coordinate_set_parse_igc(set, igc_file, &read_task);

        size_t initial_length = set->length;
        coordinate_set_trim(set);
        coordinate_set_repair(set);
        coordinate_set_simplify(set, 1500);
        coordinate_set_extrema(set);

        json_t *_section = json_object_get(data, "section");
        size_t section;
        if (_section) {
            section = json_integer_value(_section);
            coordinate_set_select_section(set, section, 0);
        }

        if (set->subset_count == 1) {

            task_t *task = parse_task(_task);
            if (!task) {
                task = read_task;
            }

            distance_map_t *map = NEW(distance_map_t, 1);
            distance_map_init(map, set);

            char *ids;

            printf("{");
            printf("\"validated\": %d,", validate_file(source));
            printf("\"total_points\": %d,", initial_length);
            printf("\"sets\": %d,", set->subset_count);
            printf("\"date\": \"%04d-%02d-%02d\",", set->year, set->month, set->day);
            printf("\"start_time\": %d,", set->first->timestamp);
            printf("\"duration\": %d,", set->last->timestamp - set->first->timestamp);
            printf("\"points\": %d,", set->length);
            printf("\"stats\": {", set->length);
            printf("\"height\" : {\"min\": %d, \"max\": %d},", set->first->ele, set->last->ele);
            printf("\"speed\" : {\"min\": %d, \"max\": %d},", set->first->speed, set->last->speed);
            printf("\"climb_rate\" : {\"min\": %d, \"max\": %d}", set->first->climb_rate, set->last->climb_rate);
            printf("},");
            printf("\"task\": {", set->length);

            task_t *od, *or, *tr, *ft;

            od = distance_map_score_open_distance_3tp(map);
            or = distance_map_score_out_and_return(map);
            tr = distance_map_score_triangle(map, 0.28);
            ft = distance_map_score_triangle(map, 0);

            format_task(od, "open_distance", OPEN_DISTANCE);
            printf(",");

            format_task(or, "out_and_return", OUT_AND_RETURN);
            printf(",");

            format_task(tr, "triangle", TRIANGLE);
            printf(",");

            format_task(ft, "flat_triangle", FLAT_TRIANGLE);

            if (task) {
                printf(",");
                format_task(task, "declared", task->type);
                printf(", \"complete\": %d", task_completes_task(task, set));
            }

            printf("}, \"output\": {\"js\": \"%s\",\"kml\": \"%s\",\"earth\": \"%s\"}", out_file_1, out_file_2, out_file_3);

            formatter_t *formatter;

            formatter = NEW(formatter_t, 1);
            formatter_js_init(formatter, set, 1, od, or, tr, ft);
            formatter_js_output(formatter, out_file_1);
            free(formatter);

            formatter = NEW(formatter_t, 1);
            formatter_kml_init(formatter, set, pilot ?: "N/A", od, or, tr, ft, task);
            formatter_kml_output(formatter, out_file_2);
            free(formatter);

            formatter = NEW(formatter_t, 1);
            formatter_kml_earth_init(formatter, set, pilot ?: "N/A", od, or, tr, ft, task);
            formatter_kml_earth_output(formatter, out_file_3);
            free(formatter);

            printf("}");

            if (od) {
                task_deinit(od);
            }
            if (or) {
                task_deinit(or);
            }
            if (tr) {
                task_deinit(tr);
            }
            distance_map_deinit(map);

        } else {
Пример #11
0
int main (int argc, char*argv[]){
    int opt;
    int vflag=0;
    int eflag=0; 
    char output_encoding[20]="";
    const char *input_path=NULL;
    const char *output_path=NULL;
                                                           
    enum encoding output_encoding_enum=INVALIDENCODING; 
    enum encoding input_encoding_enum=INVALIDENCODING;
    FILE *input_file_pointer=NULL; 
    while((opt = getopt(argc, argv, "hve:")) != -1){
        switch (opt){
            case'h':
                print_usage();
                exit(EXIT_SUCCESS);
                break;  
            case'v':
                vflag++;
                break;
            case 'e':
                eflag=1;
                strncpy(output_encoding, optarg, 20);
                break;
            case '?':
            default:
                print_usage();
                exit(EXIT_FAILURE);
                break;
        }  
    } 
    // output_encoding is something we alreay get here. 
    if ((output_encoding_enum=e_flag_command(eflag, output_encoding))==INVALIDEFLAG){
        print_usage();
        exit(EXIT_FAILURE);
    }
    // check if there is input file and out put file; 
    if( get_file_argument(argc, optind) ==0 ){
        print_usage();
        exit(EXIT_FAILURE);
    }
    // if there is get the input file and output file here 
    input_path = argv[optind++];
    output_path = argv[optind++];  
    //validate the file arguments   checek if 
    if ( validate_file(input_path, output_path)==0){
        print_usage();
        exit(EXIT_FAILURE);
    } 
    // check what kind of input_encoding it is?
    if ( (input_encoding_enum =input_type_check(input_path,output_path))==INVALIDENCODING){
        print_usage();
        exit(EXIT_FAILURE);
    }

    // open and write the BOM to the output file 
    FILE *output_file_pointer=NULL;
    if ( (output_file_pointer = fopen(output_path,"w+"))==NULL){  // file is created if dose not exist 
        print_usage();
        exit(EXIT_FAILURE); 
    }
    else{
        printf("the file %s  was successfully created\n", output_path);
    }
    const char BOM_UTF8[3]={0xEF,0XBB,0XBF}; // UTF8 DO NOT NEED TO CONSIDER ABOUT LE OR BE write directly 
    const char BOM_UTF16LE[2]={0XFF,0XFE};   //
    const char BOM_UTF16BE[2]={0XFE,0XFF};  //
    //size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
    if(output_encoding_enum==UTF8){
        fwrite(BOM_UTF8,3,1,output_file_pointer);
    }
    else if(output_encoding_enum==UTF16LE){
        fwrite(BOM_UTF16LE,2,1,output_file_pointer);
    }
    else if(output_encoding_enum==UTF16BE){
        fwrite(BOM_UTF16BE,2,1,output_file_pointer);
    }
    else{
        print_usage();
        exit(EXIT_FAILURE);
    }  

    input_file_pointer = fopen(input_path,"r");   
    if(input_encoding_enum==UTF8){
        fseek(input_file_pointer,3,SEEK_CUR);
    }  
    else if((input_encoding_enum==UTF16LE) || (input_encoding_enum==UTF16BE)){
        fseek(input_file_pointer,2,SEEK_CUR);
    }
    uint8_t read_buffer[4]=""; 
    auto size_t filebytes_read=0;   
    if(vflag==1){   
        fprintf(stdout, "+--------------+-----------------+----------------+\n");
        fprintf(stdout, "|     ASCII    |    # of bytes   |    codepoint   |\n");
        fprintf(stdout, "+--------------+-----------------+----------------+\n");
    }
    else if(vflag==2){
        fprintf(stdout,"+--------------+-----------------+-----------------+---------------+\n");
        fprintf(stdout,"|      ASCII   |    # of bytes   |     codepoint   |      input    |\n");
        fprintf(stdout,"+--------------+-----------------+-----------------+---------------+\n");
    }
    else if(vflag>=3){
        fprintf(stdout,"+--------------+-----------------+-----------------+---------------+---------------+\n");
        fprintf(stdout,"|      ASCII   |     # of bytes  |    codepoint    |      input    |     output    |\n");
        fprintf(stdout,"+--------------+-----------------+-----------------+---------------+---------------+\n");
    }


    while(filebytes_read = fread(read_buffer,1,1,input_file_pointer) == 1){ // if can sucessfully read the data 
        read_buffer[1]=0;
        read_buffer[2]=0;
        read_buffer[3]=0; // clear 
        uint8_t write_buffer[4]={0,0,0,0};// clear
        int moreByteToRead=0;
        int *moreToRead=&moreByteToRead; // get the pointer 
        int getByteToWrite=0;
        int *ByteToWrite=&getByteToWrite;
        int getcodePoint =-1;
        int *codePoint = &getcodePoint; 
        // char readin_value=-1;
        char read_in[10] = " ";//
        // char writeout_value=-1;
        char write_out[10]=" ";//

        if(input_encoding_enum==UTF8){
            bytesRead_UTF8(read_buffer, moreToRead);   //1 check how many bytes do I need to read to the buffer
            fread((read_buffer+1), (*moreToRead),1,input_file_pointer);   //2 read the bytes to buffer; fread(buffer,n,1,pointer_holder);
            getCodePointFromUFT8(read_buffer,moreToRead, codePoint); //3 convert to code point
            if(moreByteToRead==0){
                print_chars(read_buffer, 1, read_in);
            }
            else if(moreByteToRead==1){
                print_chars(read_buffer, 2, read_in);
            }
            else if(moreByteToRead==2){
                print_chars(read_buffer, 3, read_in);        
            }
            else if(moreByteToRead==3){
                print_chars(read_buffer, 4, read_in);
            }
        }                                                         
        else if(input_encoding_enum==UTF16LE){
            fread((read_buffer+1), 1,1,input_file_pointer);     // 1, read another byte 
            checkIfSurrogate16LE (read_buffer,moreToRead);    // 2. check if surrogate? if it is read TWO more byte, so also passing the moretoread pointer
            fread((read_buffer+2), (*moreToRead),1,input_file_pointer);  // keep reading, if it is not surrogate then reading ZERO Byte
            getCodePointFromUFT16LE(read_buffer, moreToRead, codePoint);   //convert to code point
            if(moreByteToRead==0){
                print_chars(read_buffer, 2, read_in);
            }
            else if(moreByteToRead==2){
                print_chars(read_buffer, 4, read_in);
            }
        }
        else if(input_encoding_enum==UTF16BE){
            fread((read_buffer+1), 1,1,input_file_pointer);     // 1, read another byte 
            checkIfSurrogate16BE (read_buffer,moreToRead);    // 2. check if surrogate? if it is read TWO more byte, so also passing the moretoread pointer
            fread((read_buffer+2), (*moreToRead),1,input_file_pointer);  // keep reading, if it is not surrogate then reading ZERO Byte
            getCodePointFromUFT16BE(read_buffer, moreToRead, codePoint);    //convert to code point
            if(moreByteToRead==0){
                print_chars(read_buffer, 2, read_in);
            }
            else if(moreByteToRead==2){
                print_chars(read_buffer, 4, read_in);
            }
        }
        codePointConvert(getcodePoint, output_encoding_enum,write_buffer,ByteToWrite,write_out); // convert code point to the UTF8/UTF16LE/UTF16BE type output
        fwrite(write_buffer,getByteToWrite,1,output_file_pointer);
        if(input_encoding_enum==UTF8){
            vflag_print_utf8( vflag, getcodePoint, read_in, write_out, moreByteToRead,read_buffer);
        }
        else if(input_encoding_enum == UTF16LE || input_encoding_enum==UTF16BE)
            vflag_print_utf16le( vflag, getcodePoint, read_in, write_out, moreByteToRead);
    }
    // after everything is done close the inputfile and close the inputfile
    fclose(output_file_pointer);
    fclose(input_file_pointer); // point_holder is the inputfilepointer
#ifdef CSE320
print_info(input_path,output_path, input_encoding_enum, output_encoding_enum);
#else 
#endif
}
Пример #12
0
/**
 * main:
 **/
int
main (int argc, char *argv[])
{
	AsValidateToolPrivate *priv;
	gboolean ret;
	gboolean verbose = FALSE;
	gboolean version = FALSE;
	gboolean no_color = FALSE;
	GError *error = NULL;
	guint retval = 1;
	guint i;

	const GOptionEntry options[] = {
		{ "verbose", 0, 0, G_OPTION_ARG_NONE, &verbose,
			_("Show extra debugging information"), NULL },
		{ "version", 0, 0, G_OPTION_ARG_NONE, &version,
			_("Show program version"), NULL },
		{ "no-color", 0, 0, G_OPTION_ARG_NONE, &no_color,
			_("Show program version"), NULL },
		{ NULL}
	};

	setlocale (LC_ALL, "");

	/* create helper object */
	priv = g_new0 (AsValidateToolPrivate, 1);

	/* get a list of the commands */
	priv->context = g_option_context_new (NULL);

	g_set_application_name (_("AppStream Validation Utility"));
	g_option_context_add_main_entries (priv->context, options, NULL);
	ret = g_option_context_parse (priv->context, &argc, &argv, &error);
	if (!ret) {
		g_print ("%s: %s\n",
			 _("Failed to parse arguments"),
			 error->message);
		g_error_free (error);
		goto out;
	}

	/* just a hack, we might need proper message handling later */
	if (verbose) {
		g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
	}

	if (version) {
		g_print ("Appstream validation tool version: %s\n", VERSION);
		retval = 0;
		goto out;
	}

	if (argc <= 1) {
		g_print ("%s\n",
				 _("You need to specify a file to validate!"));
		goto out;
	}

	ret = TRUE;
	for (i = 1; i < argc; i++) {
		gboolean tmp_ret;
		tmp_ret = validate_file (argv[i], !no_color);
		if (!tmp_ret)
			ret = FALSE;
	}

	if (!ret) {
		g_print ("%s\n",
				 _("Validation failed."));
		retval = 3;
	}

	/* success? */
	if (ret)
		retval = 0;
out:
	if (priv != NULL) {
		g_option_context_free (priv->context);
		g_free (priv);
	}
	return retval;
}