自学教程：C++ send_sideband函数代码示例

static void send_request(int fd, struct strbuf *buf){	if (args.stateless_rpc) {		send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);		packet_flush(fd);	} else		safe_write(fd, buf->buf, buf->len);}

static void send_request(struct fetch_pack_args *args,			 int fd, struct strbuf *buf){	if (args->stateless_rpc) {		send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);		packet_flush(fd);	} else		write_or_die(fd, buf->buf, buf->len);}

static void error_clnt(const char *fmt, ...){	struct strbuf buf = STRBUF_INIT;	va_list params;	va_start(params, fmt);	strbuf_vaddf(&buf, fmt, params);	va_end(params);	send_sideband(1, 3, buf.buf, buf.len, LARGE_PACKET_MAX);	die("sent error to the client: %s", buf.buf);}

static ssize_t process_input(int child_fd, int band){	char buf[16384];	ssize_t sz = read(child_fd, buf, sizeof(buf));	if (sz < 0) {		if (errno != EAGAIN && errno != EINTR)			error_clnt("read error: %s/n", strerror(errno));		return sz;	}	send_sideband(1, band, buf, sz, LARGE_PACKET_MAX);	return sz;}

static void error_clnt(const char *fmt, ...){	char buf[1024];	va_list params;	int len;	va_start(params, fmt);	len = vsprintf(buf, fmt, params);	va_end(params);	send_sideband(1, 3, buf, len, LARGE_PACKET_MAX);	die("sent error to the client: %s", buf);}

static int copy_to_sideband(int in, int out, void *arg){	char data[128];	while (1) {		ssize_t sz = xread(in, data, sizeof(data));		if (sz <= 0)			break;		send_sideband(1, 2, data, sz, use_sideband);	}	close(in);	return 0;}

static ssize_t send_client_data(int fd, const char *data, ssize_t sz){	if (use_sideband)		return send_sideband(1, fd, data, sz, use_sideband);	if (fd == 3)		/* emergency quit */		fd = 2;	if (fd == 2) {		/* XXX: are we happy to lose stuff here? */		xwrite(fd, data, sz);		return sz;	}	return safe_write(fd, data, sz);}

static void send_client_data(int fd, const char *data, ssize_t sz){	if (use_sideband) {		send_sideband(1, fd, data, sz, use_sideband);		return;	}	if (fd == 3)		/* emergency quit */		fd = 2;	if (fd == 2) {		/* XXX: are we happy to lose stuff here? */		xwrite(fd, data, sz);		return;	}	write_or_die(fd, data, sz);}

static void report_message(const char *prefix, const char *err, va_list params){	int sz = strlen(prefix);	char msg[4096];	strncpy(msg, prefix, sz);	sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);	if (sz > (sizeof(msg) - 1))		sz = sizeof(msg) - 1;	msg[sz++] = '/n';	if (use_sideband)		send_sideband(1, 2, msg, sz, use_sideband);	else		xwrite(2, msg, sz);}

static void report(struct command *commands, const char *unpack_status){	struct command *cmd;	struct strbuf buf = STRBUF_INIT;	packet_buf_write(&buf, "unpack %s/n",			 unpack_status ? unpack_status : "ok");	for (cmd = commands; cmd; cmd = cmd->next) {		if (!cmd->error_string)			packet_buf_write(&buf, "ok %s/n",					 cmd->ref_name);		else			packet_buf_write(&buf, "ng %s %s/n",					 cmd->ref_name, cmd->error_string);	}	packet_buf_flush(&buf);	if (use_sideband)		send_sideband(1, 1, buf.buf, buf.len, use_sideband);	else		safe_write(1, buf.buf, buf.len);	strbuf_release(&buf);}

/* * Make a pack stream and spit it out into file descriptor fd */static int pack_objects(int fd, struct ref *refs, struct extra_have_objects *extra, struct send_pack_args *args){	/*	 * The child becomes pack-objects --revs; we feed	 * the revision parameters to it via its stdin and	 * let its stdout go back to the other end.	 */	const char *argv[] = {		"pack-objects",		"--all-progress-implied",		"--revs",		"--stdout",		NULL,		NULL,		NULL,		NULL,		NULL,	};	struct child_process po;	int i;	i = 4;	if (args->use_thin_pack)		argv[i++] = "--thin";	if (args->use_ofs_delta)		argv[i++] = "--delta-base-offset";	if (args->quiet)		argv[i++] = "-q";	if (args->progress)		argv[i++] = "--progress";	memset(&po, 0, sizeof(po));	po.argv = argv;	po.in = -1;	po.out = args->stateless_rpc ? -1 : fd;	po.git_cmd = 1;	if (start_command(&po))		die_errno("git pack-objects failed");	/*	 * We feed the pack-objects we just spawned with revision	 * parameters by writing to the pipe.	 */	for (i = 0; i < extra->nr; i++)		if (!feed_object(extra->array[i], po.in, 1))			break;	while (refs) {		if (!is_null_sha1(refs->old_sha1) &&		    !feed_object(refs->old_sha1, po.in, 1))			break;		if (!is_null_sha1(refs->new_sha1) &&		    !feed_object(refs->new_sha1, po.in, 0))			break;		refs = refs->next;	}	close(po.in);	if (args->stateless_rpc) {		char *buf = xmalloc(LARGE_PACKET_MAX);		while (1) {			ssize_t n = xread(po.out, buf, LARGE_PACKET_MAX);			if (n <= 0)				break;			send_sideband(fd, -1, buf, n, LARGE_PACKET_MAX);		}		free(buf);		close(po.out);		po.out = -1;	}	if (finish_command(&po))		return -1;	return 0;}

int send_pack(struct send_pack_args *args,	      int fd[], struct child_process *conn,	      struct ref *remote_refs,	      struct extra_have_objects *extra_have){	int in = fd[0];	int out = fd[1];	struct strbuf req_buf = STRBUF_INIT;	struct ref *ref;	int new_refs;	int allow_deleting_refs = 0;	int status_report = 0;	int use_sideband = 0;	unsigned cmds_sent = 0;	int ret;	struct async demux;	/* Does the other end support the reporting? */	if (server_supports("report-status"))		status_report = 1;	if (server_supports("delete-refs"))		allow_deleting_refs = 1;	if (server_supports("ofs-delta"))		args->use_ofs_delta = 1;	if (server_supports("side-band-64k"))		use_sideband = 1;	if (!remote_refs) {		fprintf(stderr, "No refs in common and none specified; doing nothing./n"			"Perhaps you should specify a branch such as 'master'./n");		return 0;	}	/*	 * Finally, tell the other end!	 */	new_refs = 0;	for (ref = remote_refs; ref; ref = ref->next) {		if (!ref->peer_ref && !args->send_mirror)			continue;		/* Check for statuses set by set_ref_status_for_push() */		switch (ref->status) {		case REF_STATUS_REJECT_NONFASTFORWARD:		case REF_STATUS_UPTODATE:			continue;		default:			; /* do nothing */		}		if (ref->deletion && !allow_deleting_refs) {			ref->status = REF_STATUS_REJECT_NODELETE;			continue;		}		if (!ref->deletion)			new_refs++;		if (args->dry_run) {			ref->status = REF_STATUS_OK;		} else {			char *old_hex = sha1_to_hex(ref->old_sha1);			char *new_hex = sha1_to_hex(ref->new_sha1);			if (!cmds_sent && (status_report || use_sideband)) {				packet_buf_write(&req_buf, "%s %s %s%c%s%s",					old_hex, new_hex, ref->name, 0,					status_report ? " report-status" : "",					use_sideband ? " side-band-64k" : "");			}			else				packet_buf_write(&req_buf, "%s %s %s",					old_hex, new_hex, ref->name);			ref->status = status_report ?				REF_STATUS_EXPECTING_REPORT :				REF_STATUS_OK;			cmds_sent++;		}	}	if (args->stateless_rpc) {		if (!args->dry_run && cmds_sent) {			packet_buf_flush(&req_buf);			send_sideband(out, -1, req_buf.buf, req_buf.len, LARGE_PACKET_MAX);		}	} else {		safe_write(out, req_buf.buf, req_buf.len);		packet_flush(out);	}	strbuf_release(&req_buf);	if (use_sideband && cmds_sent) {		memset(&demux, 0, sizeof(demux));		demux.proc = sideband_demux;		demux.data = fd;		demux.out = -1;		if (start_async(&demux))			die("send-pack: unable to fork off sideband demultiplexer");		in = demux.out;	}//.........这里部分代码省略.........

static int copy_to_sideband(int in, int out, void *arg){	char data[128];	int keepalive_active = 0;	if (keepalive_in_sec <= 0)		use_keepalive = KEEPALIVE_NEVER;	if (use_keepalive == KEEPALIVE_ALWAYS)		keepalive_active = 1;	while (1) {		ssize_t sz;		if (keepalive_active) {			struct pollfd pfd;			int ret;			pfd.fd = in;			pfd.events = POLLIN;			ret = poll(&pfd, 1, 1000 * keepalive_in_sec);			if (ret < 0) {				if (errno == EINTR)					continue;				else					break;			} else if (ret == 0) {				/* no data; send a keepalive packet */				static const char buf[] = "0005/1";				write_or_die(1, buf, sizeof(buf) - 1);				continue;			} /* else there is actual data to read */		}		sz = xread(in, data, sizeof(data));		if (sz <= 0)			break;		if (use_keepalive == KEEPALIVE_AFTER_NUL && !keepalive_active) {			const char *p = memchr(data, '/0', sz);			if (p) {				/*				 * The NUL tells us to start sending keepalives. Make				 * sure we send any other data we read along				 * with it.				 */				keepalive_active = 1;				send_sideband(1, 2, data, p - data, use_sideband);				send_sideband(1, 2, p + 1, sz - (p - data + 1), use_sideband);				continue;			}		}		/*		 * Either we're not looking for a NUL signal, or we didn't see		 * it yet; just pass along the data.		 */		send_sideband(1, 2, data, sz, use_sideband);	}	close(in);	return 0;}

/* * Make a pack stream and spit it out into file descriptor fd */static int pack_objects(int fd, struct ref *refs, struct sha1_array *extra, struct send_pack_args *args){	/*	 * The child becomes pack-objects --revs; we feed	 * the revision parameters to it via its stdin and	 * let its stdout go back to the other end.	 */	const char *argv[] = {		"pack-objects",		"--all-progress-implied",		"--revs",		"--stdout",		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,	};	struct child_process po = CHILD_PROCESS_INIT;	FILE *po_in;	int i;	i = 4;	if (args->use_thin_pack)		argv[i++] = "--thin";	if (args->use_ofs_delta)		argv[i++] = "--delta-base-offset";	if (args->quiet || !args->progress)		argv[i++] = "-q";	if (args->progress)		argv[i++] = "--progress";	if (is_repository_shallow())		argv[i++] = "--shallow";	po.argv = argv;	po.in = -1;	po.out = args->stateless_rpc ? -1 : fd;	po.git_cmd = 1;	if (start_command(&po))		die_errno("git pack-objects failed");	/*	 * We feed the pack-objects we just spawned with revision	 * parameters by writing to the pipe.	 */	po_in = xfdopen(po.in, "w");	for (i = 0; i < extra->nr; i++)		feed_object(extra->sha1[i], po_in, 1);	while (refs) {		if (!is_null_oid(&refs->old_oid))			feed_object(refs->old_oid.hash, po_in, 1);		if (!is_null_oid(&refs->new_oid))			feed_object(refs->new_oid.hash, po_in, 0);		refs = refs->next;	}	fflush(po_in);	if (ferror(po_in))		die_errno("error writing to pack-objects");	fclose(po_in);	if (args->stateless_rpc) {		char *buf = xmalloc(LARGE_PACKET_MAX);		while (1) {			ssize_t n = xread(po.out, buf, LARGE_PACKET_MAX);			if (n <= 0)				break;			send_sideband(fd, -1, buf, n, LARGE_PACKET_MAX);		}		free(buf);		close(po.out);		po.out = -1;	}	if (finish_command(&po))		return -1;	return 0;}

//.........这里部分代码省略.........		else			ref->status = REF_STATUS_EXPECTING_REPORT;	}	/*	 * Finally, tell the other end!	 */	for (ref = remote_refs; ref; ref = ref->next) {		char *old_hex, *new_hex;		if (args->dry_run || push_cert_nonce)			continue;		if (check_to_send_update(ref, args) < 0)			continue;		old_hex = oid_to_hex(&ref->old_oid);		new_hex = oid_to_hex(&ref->new_oid);		if (!cmds_sent) {			packet_buf_write(&req_buf,					 "%s %s %s%c%s",					 old_hex, new_hex, ref->name, 0,					 cap_buf.buf);			cmds_sent = 1;		} else {			packet_buf_write(&req_buf, "%s %s %s",					 old_hex, new_hex, ref->name);		}	}	if (args->stateless_rpc) {		if (!args->dry_run && (cmds_sent || is_repository_shallow())) {			packet_buf_flush(&req_buf);			send_sideband(out, -1, req_buf.buf, req_buf.len, LARGE_PACKET_MAX);		}	} else {		write_or_die(out, req_buf.buf, req_buf.len);		packet_flush(out);	}	strbuf_release(&req_buf);	strbuf_release(&cap_buf);	if (use_push_options) {		struct string_list_item *item;		struct strbuf sb = STRBUF_INIT;		for_each_string_list_item(item, args->push_options)			packet_buf_write(&sb, "%s", item->string);		write_or_die(out, sb.buf, sb.len);		packet_flush(out);		strbuf_release(&sb);	}	if (use_sideband && cmds_sent) {		memset(&demux, 0, sizeof(demux));		demux.proc = sideband_demux;		demux.data = fd;		demux.out = -1;		demux.isolate_sigpipe = 1;		if (start_async(&demux))			die("send-pack: unable to fork off sideband demultiplexer");		in = demux.out;	}	if (need_pack_data && cmds_sent) {

/* * Make a pack stream and spit it out into file descriptor fd */static int pack_objects(int fd, struct ref *refs, struct sha1_array *extra, struct send_pack_args *args){	/*	 * The child becomes pack-objects --revs; we feed	 * the revision parameters to it via its stdin and	 * let its stdout go back to the other end.	 */	const char *argv[] = {		"pack-objects",		"--all-progress-implied",		"--revs",		"--stdout",		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,	};	struct child_process po = CHILD_PROCESS_INIT;	FILE *po_in;	int i;	int rc;	i = 4;	if (args->use_thin_pack)		argv[i++] = "--thin";	if (args->use_ofs_delta)		argv[i++] = "--delta-base-offset";	if (args->quiet || !args->progress)		argv[i++] = "-q";	if (args->progress)		argv[i++] = "--progress";	if (is_repository_shallow())		argv[i++] = "--shallow";	po.argv = argv;	po.in = -1;	po.out = args->stateless_rpc ? -1 : fd;	po.git_cmd = 1;	if (start_command(&po))		die_errno("git pack-objects failed");	/*	 * We feed the pack-objects we just spawned with revision	 * parameters by writing to the pipe.	 */	po_in = xfdopen(po.in, "w");	for (i = 0; i < extra->nr; i++)		feed_object(extra->sha1[i], po_in, 1);	while (refs) {		if (!is_null_oid(&refs->old_oid))			feed_object(refs->old_oid.hash, po_in, 1);		if (!is_null_oid(&refs->new_oid))			feed_object(refs->new_oid.hash, po_in, 0);		refs = refs->next;	}	fflush(po_in);	if (ferror(po_in))		die_errno("error writing to pack-objects");	fclose(po_in);	if (args->stateless_rpc) {		char *buf = xmalloc(LARGE_PACKET_MAX);		while (1) {			ssize_t n = xread(po.out, buf, LARGE_PACKET_MAX);			if (n <= 0)				break;			send_sideband(fd, -1, buf, n, LARGE_PACKET_MAX);		}		free(buf);		close(po.out);		po.out = -1;	}	rc = finish_command(&po);	if (rc) {		/*		 * For a normal non-zero exit, we assume pack-objects wrote		 * something useful to stderr. For death by signal, though,		 * we should mention it to the user. The exception is SIGPIPE		 * (141), because that's a normal occurence if the remote end		 * hangs up (and we'll report that by trying to read the unpack		 * status).		 */		if (rc > 128 && rc != 141)			error("pack-objects died of signal %d", rc - 128);		return -1;	}	return 0;}