Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/cvs/remote.c	Lines:	0	139	0.0 %
Date:	2017-11-13	Branches:	0	104	0.0 %


/*	$OpenBSD: remote.c,v 1.32 2017/08/28 19:33:20 otto Exp $	*/
/*
 * Copyright (c) 2006 Joris Vink <joris@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>	/* MAXBSIZE */
#include <sys/stat.h>

#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "atomicio.h"
#include "cvs.h"
#include "remote.h"

#define MINIMUM(a, b)	(((a) < (b)) ? (a) : (b))

struct cvs_resp *
cvs_remote_get_response_info(const char *response)
{
	int i;

	for (i = 0; cvs_responses[i].supported != -1; i++) {
		if (!strcmp(cvs_responses[i].name, response))
			return (&(cvs_responses[i]));
	}

	return (NULL);
}

struct cvs_req *
cvs_remote_get_request_info(const char *request)
{
	int i;

	for (i = 0; cvs_requests[i].supported != -1; i++) {
		if (!strcmp(cvs_requests[i].name, request))
			return (&(cvs_requests[i]));
	}

	return (NULL);
}

void
cvs_remote_output(char *data)
{
	FILE *out;
	size_t len;
	char nl = '\n';

	if (cvs_server_active)
		out = stdout;
	else
		out = current_cvsroot->cr_srvin;

	fputs(data, out);
	fputs("\n", out);

	if (cvs_server_active == 0 && cvs_client_inlog_fd != -1) {
		len = strlen(data);
		if (atomicio(vwrite, cvs_client_inlog_fd, data, len) != len ||
		    atomicio(vwrite, cvs_client_inlog_fd, &nl, 1) != 1)
			fatal("failed to write to log file");
	}
}

char *
cvs_remote_input(void)
{
	FILE *in;
	size_t len;
	char nl = '\n';
	char *data, *ldata;

	if (cvs_server_active)
		in = stdin;
	else
		in = current_cvsroot->cr_srvout;

	data = fgetln(in, &len);
	if (data == NULL) {
		if (sig_received != 0)
			fatal("received signal %d", sig_received);

		if (cvs_server_active) {
			cvs_cleanup();
			exit(0);
		}

		fatal("the connection has been closed by the server");
	}

	if (data[len - 1] == '\n') {
		data[len - 1] = '\0';
		ldata = xstrdup(data);
	} else {
		ldata = xmalloc(len + 1);
		memcpy(ldata, data, len);
		ldata[len] = '\0';
	}

	if (cvs_server_active == 0 && cvs_client_outlog_fd != -1) {
		len = strlen(data);
		if (atomicio(vwrite, cvs_client_outlog_fd, data, len) != len ||
		    atomicio(vwrite, cvs_client_outlog_fd, &nl, 1) != 1)
			fatal("failed to write to log file");
	}

	return (ldata);
}

void
cvs_remote_receive_file(int fd, size_t len)
{
	FILE *in;
	char data[MAXBSIZE];
	size_t nread, nleft, toread;

	if (cvs_server_active)
		in = stdin;
	else
		in = current_cvsroot->cr_srvout;

	nleft = len;

	while (nleft > 0) {
		toread = MINIMUM(nleft, MAXBSIZE);

		nread = fread(data, sizeof(char), toread, in);
		if (nread == 0)
			fatal("error receiving file");

		if (atomicio(vwrite, fd, data, nread) != nread)
			fatal("failed to write %zu bytes", nread);

		if (cvs_server_active == 0 && cvs_client_outlog_fd != -1 &&
		    atomicio(vwrite, cvs_client_outlog_fd, data, nread)
		    != nread)
			fatal("failed to write to log file");

		nleft -= nread;
	}
}

void
cvs_remote_send_file(const char *path, int _fd)
{
	int fd;
	FILE *out, *in;
	size_t ret, rw;
	off_t total;
	struct stat st;
	char buf[18], data[MAXBSIZE];

	if (cvs_server_active)
		out = stdout;
	else
		out = current_cvsroot->cr_srvin;

	fd = dup(_fd);
	if (fd == -1)
		fatal("cvs_remote_send_file: dup: %s", strerror(errno));

	if (lseek(fd, 0, SEEK_SET) < 0)
		fatal("cvs_remote_send_file: %s: lseek: %s", path,
		    strerror(errno));

	if (fstat(fd, &st) == -1)
		fatal("cvs_remote_send_file: %s: fstat: %s", path,
		    strerror(errno));

	cvs_modetostr(st.st_mode, buf, sizeof(buf));
	cvs_remote_output(buf);

	(void)xsnprintf(buf, sizeof(buf), "%lld", st.st_size);
	cvs_remote_output(buf);

	if ((in = fdopen(fd, "r")) == NULL)
		fatal("cvs_remote_send_file: fdopen %s", strerror(errno));

	total = 0;
	while ((ret = fread(data, sizeof(char), MAXBSIZE, in)) != 0) {
		rw = fwrite(data, sizeof(char), ret, out);
		if (rw != ret)
			fatal("failed to write %zu bytes", ret);

		if (cvs_server_active == 0 && cvs_client_inlog_fd != -1 &&
		    atomicio(vwrite, cvs_client_inlog_fd, data, ret) != ret)
			fatal("failed to write to log file");

		total += ret;
	}

	if (total != st.st_size)
		fatal("length mismatch, %lld vs %lld", total, st.st_size);

	(void)fclose(in);
}

void
cvs_remote_send_file_buf(char *file, BUF *bp, mode_t mode)
{
	char buf[18];
	u_char *data;
	size_t len, ret;

	if (cvs_server_active != 1)
		fatal("cvs_remote_send_file_buf is server only");

	len = buf_len(bp);
	data = buf_release(bp);

	cvs_modetostr(mode, buf, sizeof(buf));
	cvs_remote_output(buf);

	(void)xsnprintf(buf, sizeof(buf), "%ld", len);
	cvs_remote_output(buf);

	ret = fwrite(data, sizeof(char), len, stdout);
	if (ret != len)
		cvs_log(LP_ERR, "warning: sent %s truncated", file);

	if (cvs_server_active == 0 && cvs_client_inlog_fd != -1 &&
	    atomicio(vwrite, cvs_client_inlog_fd, data, len) != len)
		fatal("failed to write to log file");

	free(data);
}

void
cvs_remote_classify_file(struct cvs_file *cf)
{
	struct stat st;
	CVSENTRIES *entlist;

	entlist = cvs_ent_open(cf->file_wd);
	cf->file_ent = cvs_ent_get(entlist, cf->file_name);

	if (cf->file_ent != NULL && cf->file_ent->ce_status != CVS_ENT_REG) {
		if (cf->file_ent->ce_status == CVS_ENT_ADDED) {
			if (cf->fd != -1)
				cf->file_status = FILE_ADDED;
			else
				cf->file_status = FILE_UNKNOWN;
		} else {
			cf->file_status = FILE_REMOVED;
		}

		return;
	}

	if (cf->file_ent != NULL) {
		if (cf->file_ent->ce_type == CVS_ENT_DIR)
			cf->file_type = CVS_DIR;
		else
			cf->file_type = CVS_FILE;
	}

	if (cf->fd != -1)
		cf->file_flags |= FILE_ON_DISK;

	if ((cf->file_flags & FILE_ON_DISK) && cf->file_ent != NULL) {
		if (fstat(cf->fd, &st) == -1)
			fatal("cvs_remote_classify_file(%s): %s", cf->file_path,
			    strerror(errno));

		if (st.st_mtime != cf->file_ent->ce_mtime ||
		    cf->file_ent->ce_conflict != NULL)
			cf->file_status = FILE_MODIFIED;
		else
			cf->file_status = FILE_UPTODATE;
	} else if (!(cf->file_flags & FILE_ON_DISK)) {
		cf->file_status = FILE_UNKNOWN;
	}

	if (cvs_cmdop == CVS_OP_IMPORT && cf->file_type == CVS_FILE)
		cf->file_status = FILE_MODIFIED;
}


void
cvs_validate_directory(const char *path)
{
	char *dir, *sp, *dp;

	dir = xstrdup(path);

	for (sp = dir; sp != NULL; sp = dp) {
		dp = strchr(sp, '/');
		if (dp != NULL)
			*(dp++) = '\0';

		if (!strcmp(sp, ".."))
			fatal("path validation failed!");
	}

	free(dir);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: remote.c,v 1.32 2017/08/28 19:33:20 otto Exp $ */
2			/*
3			* Copyright (c) 2006 Joris Vink <joris@openbsd.org>
4			*
5			* Permission to use, copy, modify, and distribute this software for any
6			* purpose with or without fee is hereby granted, provided that the above
7			* copyright notice and this permission notice appear in all copies.
8			*
9			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16			*/
17
18			#include <sys/param.h> /* MAXBSIZE */
19			#include <sys/stat.h>
20
21			#include <errno.h>
22			#include <fcntl.h>
23			#include <stdlib.h>
24			#include <string.h>
25			#include <unistd.h>
26
27			#include "atomicio.h"
28			#include "cvs.h"
29			#include "remote.h"
30
31			#define MINIMUM(a, b) (((a) < (b)) ? (a) : (b))
32
33			struct cvs_resp *
34			cvs_remote_get_response_info(const char *response)
35			{
36			int i;
37
38			for (i = 0; cvs_responses[i].supported != -1; i++) {
39			if (!strcmp(cvs_responses[i].name, response))
40			return (&(cvs_responses[i]));
41			}
42
43			return (NULL);
44			}
45
46			struct cvs_req *
47			cvs_remote_get_request_info(const char *request)
48			{
49			int i;
50
51			for (i = 0; cvs_requests[i].supported != -1; i++) {
52			if (!strcmp(cvs_requests[i].name, request))
53			return (&(cvs_requests[i]));
54			}
55
56			return (NULL);
57			}
58
59			void
60			cvs_remote_output(char *data)
61			{
62			FILE *out;
63			size_t len;
64			char nl = '\n';
65
66			if (cvs_server_active)
67			out = stdout;
68			else
69			out = current_cvsroot->cr_srvin;
70
71			fputs(data, out);
72			fputs("\n", out);
73
74			if (cvs_server_active == 0 && cvs_client_inlog_fd != -1) {
75			len = strlen(data);
76			if (atomicio(vwrite, cvs_client_inlog_fd, data, len) != len \|\|
77			atomicio(vwrite, cvs_client_inlog_fd, &nl, 1) != 1)
78			fatal("failed to write to log file");
79			}
80			}
81
82			char *
83			cvs_remote_input(void)
84			{
85			FILE *in;
86			size_t len;
87			char nl = '\n';
88			char data, ldata;
89
90			if (cvs_server_active)
91			in = stdin;
92			else
93			in = current_cvsroot->cr_srvout;
94
95			data = fgetln(in, &len);
96			if (data == NULL) {
97			if (sig_received != 0)
98			fatal("received signal %d", sig_received);
99
100			if (cvs_server_active) {
101			cvs_cleanup();
102			exit(0);
103			}
104
105			fatal("the connection has been closed by the server");
106			}
107
108			if (data[len - 1] == '\n') {
109			data[len - 1] = '\0';
110			ldata = xstrdup(data);
111			} else {
112			ldata = xmalloc(len + 1);
113			memcpy(ldata, data, len);
114			ldata[len] = '\0';
115			}
116
117			if (cvs_server_active == 0 && cvs_client_outlog_fd != -1) {
118			len = strlen(data);
119			if (atomicio(vwrite, cvs_client_outlog_fd, data, len) != len \|\|
120			atomicio(vwrite, cvs_client_outlog_fd, &nl, 1) != 1)
121			fatal("failed to write to log file");
122			}
123
124			return (ldata);
125			}
126
127			void
128			cvs_remote_receive_file(int fd, size_t len)
129			{
130			FILE *in;
131			char data[MAXBSIZE];
132			size_t nread, nleft, toread;
133
134			if (cvs_server_active)
135			in = stdin;
136			else
137			in = current_cvsroot->cr_srvout;
138
139			nleft = len;
140
141			while (nleft > 0) {
142			toread = MINIMUM(nleft, MAXBSIZE);
143
144			nread = fread(data, sizeof(char), toread, in);
145			if (nread == 0)
146			fatal("error receiving file");
147
148			if (atomicio(vwrite, fd, data, nread) != nread)
149			fatal("failed to write %zu bytes", nread);
150
151			if (cvs_server_active == 0 && cvs_client_outlog_fd != -1 &&
152			atomicio(vwrite, cvs_client_outlog_fd, data, nread)
153			!= nread)
154			fatal("failed to write to log file");
155
156			nleft -= nread;
157			}
158			}
159
160			void
161			cvs_remote_send_file(const char *path, int _fd)
162			{
163			int fd;
164			FILE out, in;
165			size_t ret, rw;
166			off_t total;
167			struct stat st;
168			char buf[18], data[MAXBSIZE];
169
170			if (cvs_server_active)
171			out = stdout;
172			else
173			out = current_cvsroot->cr_srvin;
174
175			fd = dup(_fd);
176			if (fd == -1)
177			fatal("cvs_remote_send_file: dup: %s", strerror(errno));
178
179			if (lseek(fd, 0, SEEK_SET) < 0)
180			fatal("cvs_remote_send_file: %s: lseek: %s", path,
181			strerror(errno));
182
183			if (fstat(fd, &st) == -1)
184			fatal("cvs_remote_send_file: %s: fstat: %s", path,
185			strerror(errno));
186
187			cvs_modetostr(st.st_mode, buf, sizeof(buf));
188			cvs_remote_output(buf);
189
190			(void)xsnprintf(buf, sizeof(buf), "%lld", st.st_size);
191			cvs_remote_output(buf);
192
193			if ((in = fdopen(fd, "r")) == NULL)
194			fatal("cvs_remote_send_file: fdopen %s", strerror(errno));
195
196			total = 0;
197			while ((ret = fread(data, sizeof(char), MAXBSIZE, in)) != 0) {
198			rw = fwrite(data, sizeof(char), ret, out);
199			if (rw != ret)
200			fatal("failed to write %zu bytes", ret);
201
202			if (cvs_server_active == 0 && cvs_client_inlog_fd != -1 &&
203			atomicio(vwrite, cvs_client_inlog_fd, data, ret) != ret)
204			fatal("failed to write to log file");
205
206			total += ret;
207			}
208
209			if (total != st.st_size)
210			fatal("length mismatch, %lld vs %lld", total, st.st_size);
211
212			(void)fclose(in);
213			}
214
215			void
216			cvs_remote_send_file_buf(char file, BUF bp, mode_t mode)
217			{
218			char buf[18];
219			u_char *data;
220			size_t len, ret;
221
222			if (cvs_server_active != 1)
223			fatal("cvs_remote_send_file_buf is server only");
224
225			len = buf_len(bp);
226			data = buf_release(bp);
227
228			cvs_modetostr(mode, buf, sizeof(buf));
229			cvs_remote_output(buf);
230
231			(void)xsnprintf(buf, sizeof(buf), "%ld", len);
232			cvs_remote_output(buf);
233
234			ret = fwrite(data, sizeof(char), len, stdout);
235			if (ret != len)
236			cvs_log(LP_ERR, "warning: sent %s truncated", file);
237
238			if (cvs_server_active == 0 && cvs_client_inlog_fd != -1 &&
239			atomicio(vwrite, cvs_client_inlog_fd, data, len) != len)
240			fatal("failed to write to log file");
241
242			free(data);
243			}
244
245			void
246			cvs_remote_classify_file(struct cvs_file *cf)
247			{
248			struct stat st;
249			CVSENTRIES *entlist;
250
251			entlist = cvs_ent_open(cf->file_wd);
252			cf->file_ent = cvs_ent_get(entlist, cf->file_name);
253
254			if (cf->file_ent != NULL && cf->file_ent->ce_status != CVS_ENT_REG) {
255			if (cf->file_ent->ce_status == CVS_ENT_ADDED) {
256			if (cf->fd != -1)
257			cf->file_status = FILE_ADDED;
258			else
259			cf->file_status = FILE_UNKNOWN;
260			} else {
261			cf->file_status = FILE_REMOVED;
262			}
263
264			return;
265			}
266
267			if (cf->file_ent != NULL) {
268			if (cf->file_ent->ce_type == CVS_ENT_DIR)
269			cf->file_type = CVS_DIR;
270			else
271			cf->file_type = CVS_FILE;
272			}
273
274			if (cf->fd != -1)
275			cf->file_flags \|= FILE_ON_DISK;
276
277			if ((cf->file_flags & FILE_ON_DISK) && cf->file_ent != NULL) {
278			if (fstat(cf->fd, &st) == -1)
279			fatal("cvs_remote_classify_file(%s): %s", cf->file_path,
280			strerror(errno));
281
282			if (st.st_mtime != cf->file_ent->ce_mtime \|\|
283			cf->file_ent->ce_conflict != NULL)
284			cf->file_status = FILE_MODIFIED;
285			else
286			cf->file_status = FILE_UPTODATE;
287			} else if (!(cf->file_flags & FILE_ON_DISK)) {
288			cf->file_status = FILE_UNKNOWN;
289			}
290
291			if (cvs_cmdop == CVS_OP_IMPORT && cf->file_type == CVS_FILE)
292			cf->file_status = FILE_MODIFIED;
293			}
294
295
296			void
297			cvs_validate_directory(const char *path)
298			{
299			char dir, sp, *dp;
300
301			dir = xstrdup(path);
302
303			for (sp = dir; sp != NULL; sp = dp) {
304			dp = strchr(sp, '/');
305			if (dp != NULL)
306			*(dp++) = '\0';
307
308			if (!strcmp(sp, ".."))
309			fatal("path validation failed!");
310			}
311
312			free(dir);
313			}