2012-10-26 17:53:53 +02:00
|
|
|
#include "builtin.h"
|
|
|
|
|
#include "commit.h"
|
|
|
|
|
#include "refs.h"
|
|
|
|
|
#include "pkt-line.h"
|
|
|
|
|
#include "sideband.h"
|
|
|
|
|
#include "run-command.h"
|
|
|
|
|
#include "remote.h"
|
2013-07-08 22:56:53 +02:00
|
|
|
#include "connect.h"
|
2012-10-26 17:53:53 +02:00
|
|
|
#include "send-pack.h"
|
|
|
|
|
#include "quote.h"
|
|
|
|
|
#include "transport.h"
|
|
|
|
|
#include "version.h"
|
|
|
|
|
|
|
|
|
|
static int feed_object(const unsigned char *sha1, int fd, int negative)
|
|
|
|
|
{
|
|
|
|
|
char buf[42];
|
|
|
|
|
|
|
|
|
|
if (negative && !has_sha1_file(sha1))
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
memcpy(buf + negative, sha1_to_hex(sha1), 40);
|
|
|
|
|
if (negative)
|
|
|
|
|
buf[0] = '^';
|
|
|
|
|
buf[40 + negative] = '\n';
|
|
|
|
|
return write_or_whine(fd, buf, 41 + negative, "send-pack: send refs");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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 || !args->progress)
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int receive_status(int in, struct ref *refs)
|
|
|
|
|
{
|
|
|
|
|
struct ref *hint;
|
|
|
|
|
int ret = 0;
|
pkt-line: provide a LARGE_PACKET_MAX static buffer
Most of the callers of packet_read_line just read into a
static 1000-byte buffer (callers which handle arbitrary
binary data already use LARGE_PACKET_MAX). This works fine
in practice, because:
1. The only variable-sized data in these lines is a ref
name, and refs tend to be a lot shorter than 1000
characters.
2. When sending ref lines, git-core always limits itself
to 1000 byte packets.
However, the only limit given in the protocol specification
in Documentation/technical/protocol-common.txt is
LARGE_PACKET_MAX; the 1000 byte limit is mentioned only in
pack-protocol.txt, and then only describing what we write,
not as a specific limit for readers.
This patch lets us bump the 1000-byte limit to
LARGE_PACKET_MAX. Even though git-core will never write a
packet where this makes a difference, there are two good
reasons to do this:
1. Other git implementations may have followed
protocol-common.txt and used a larger maximum size. We
don't bump into it in practice because it would involve
very long ref names.
2. We may want to increase the 1000-byte limit one day.
Since packets are transferred before any capabilities,
it's difficult to do this in a backwards-compatible
way. But if we bump the size of buffer the readers can
handle, eventually older versions of git will be
obsolete enough that we can justify bumping the
writers, as well. We don't have plans to do this
anytime soon, but there is no reason not to start the
clock ticking now.
Just bumping all of the reading bufs to LARGE_PACKET_MAX
would waste memory. Instead, since most readers just read
into a temporary buffer anyway, let's provide a single
static buffer that all callers can use. We can further wrap
this detail away by having the packet_read_line wrapper just
use the buffer transparently and return a pointer to the
static storage. That covers most of the cases, and the
remaining ones already read into their own LARGE_PACKET_MAX
buffers.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-20 21:02:57 +01:00
|
|
|
char *line = packet_read_line(in, NULL);
|
2013-11-30 21:55:40 +01:00
|
|
|
if (!starts_with(line, "unpack "))
|
2012-10-26 17:53:53 +02:00
|
|
|
return error("did not receive remote status");
|
pkt-line: teach packet_read_line to chomp newlines
The packets sent during ref negotiation are all terminated
by newline; even though the code to chomp these newlines is
short, we end up doing it in a lot of places.
This patch teaches packet_read_line to auto-chomp the
trailing newline; this lets us get rid of a lot of inline
chomping code.
As a result, some call-sites which are not reading
line-oriented data (e.g., when reading chunks of packfiles
alongside sideband) transition away from packet_read_line to
the generic packet_read interface. This patch converts all
of the existing callsites.
Since the function signature of packet_read_line does not
change (but its behavior does), there is a possibility of
new callsites being introduced in later commits, silently
introducing an incompatibility. However, since a later
patch in this series will change the signature, such a
commit would have to be merged directly into this commit,
not to the tip of the series; we can therefore ignore the
issue.
This is an internal cleanup and should produce no change of
behavior in the normal case. However, there is one corner
case to note. Callers of packet_read_line have never been
able to tell the difference between a flush packet ("0000")
and an empty packet ("0004"), as both cause packet_read_line
to return a length of 0. Readers treat them identically,
even though Documentation/technical/protocol-common.txt says
we must not; it also says that implementations should not
send an empty pkt-line.
By stripping out the newline before the result gets to the
caller, we will now treat the newline-only packet ("0005\n")
the same as an empty packet, which in turn gets treated like
a flush packet. In practice this doesn't matter, as neither
empty nor newline-only packets are part of git's protocols
(at least not for the line-oriented bits, and readers who
are not expecting line-oriented packets will be calling
packet_read directly, anyway). But even if we do decide to
care about the distinction later, it is orthogonal to this
patch. The right place to tighten would be to stop treating
empty packets as flush packets, and this change does not
make doing so any harder.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-20 21:02:28 +01:00
|
|
|
if (strcmp(line, "unpack ok")) {
|
2012-10-26 17:53:53 +02:00
|
|
|
error("unpack failed: %s", line + 7);
|
|
|
|
|
ret = -1;
|
|
|
|
|
}
|
|
|
|
|
hint = NULL;
|
|
|
|
|
while (1) {
|
|
|
|
|
char *refname;
|
|
|
|
|
char *msg;
|
pkt-line: provide a LARGE_PACKET_MAX static buffer
Most of the callers of packet_read_line just read into a
static 1000-byte buffer (callers which handle arbitrary
binary data already use LARGE_PACKET_MAX). This works fine
in practice, because:
1. The only variable-sized data in these lines is a ref
name, and refs tend to be a lot shorter than 1000
characters.
2. When sending ref lines, git-core always limits itself
to 1000 byte packets.
However, the only limit given in the protocol specification
in Documentation/technical/protocol-common.txt is
LARGE_PACKET_MAX; the 1000 byte limit is mentioned only in
pack-protocol.txt, and then only describing what we write,
not as a specific limit for readers.
This patch lets us bump the 1000-byte limit to
LARGE_PACKET_MAX. Even though git-core will never write a
packet where this makes a difference, there are two good
reasons to do this:
1. Other git implementations may have followed
protocol-common.txt and used a larger maximum size. We
don't bump into it in practice because it would involve
very long ref names.
2. We may want to increase the 1000-byte limit one day.
Since packets are transferred before any capabilities,
it's difficult to do this in a backwards-compatible
way. But if we bump the size of buffer the readers can
handle, eventually older versions of git will be
obsolete enough that we can justify bumping the
writers, as well. We don't have plans to do this
anytime soon, but there is no reason not to start the
clock ticking now.
Just bumping all of the reading bufs to LARGE_PACKET_MAX
would waste memory. Instead, since most readers just read
into a temporary buffer anyway, let's provide a single
static buffer that all callers can use. We can further wrap
this detail away by having the packet_read_line wrapper just
use the buffer transparently and return a pointer to the
static storage. That covers most of the cases, and the
remaining ones already read into their own LARGE_PACKET_MAX
buffers.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-20 21:02:57 +01:00
|
|
|
line = packet_read_line(in, NULL);
|
|
|
|
|
if (!line)
|
2012-10-26 17:53:53 +02:00
|
|
|
break;
|
2013-11-30 21:55:40 +01:00
|
|
|
if (!starts_with(line, "ok ") && !starts_with(line, "ng ")) {
|
2013-02-20 21:00:43 +01:00
|
|
|
error("invalid ref status from remote: %s", line);
|
2012-10-26 17:53:53 +02:00
|
|
|
ret = -1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
refname = line + 3;
|
|
|
|
|
msg = strchr(refname, ' ');
|
|
|
|
|
if (msg)
|
|
|
|
|
*msg++ = '\0';
|
|
|
|
|
|
|
|
|
|
/* first try searching at our hint, falling back to all refs */
|
|
|
|
|
if (hint)
|
|
|
|
|
hint = find_ref_by_name(hint, refname);
|
|
|
|
|
if (!hint)
|
|
|
|
|
hint = find_ref_by_name(refs, refname);
|
|
|
|
|
if (!hint) {
|
|
|
|
|
warning("remote reported status on unknown ref: %s",
|
|
|
|
|
refname);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (hint->status != REF_STATUS_EXPECTING_REPORT) {
|
|
|
|
|
warning("remote reported status on unexpected ref: %s",
|
|
|
|
|
refname);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (line[0] == 'o' && line[1] == 'k')
|
|
|
|
|
hint->status = REF_STATUS_OK;
|
|
|
|
|
else {
|
|
|
|
|
hint->status = REF_STATUS_REMOTE_REJECT;
|
|
|
|
|
ret = -1;
|
|
|
|
|
}
|
|
|
|
|
if (msg)
|
|
|
|
|
hint->remote_status = xstrdup(msg);
|
|
|
|
|
/* start our next search from the next ref */
|
|
|
|
|
hint = hint->next;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int sideband_demux(int in, int out, void *data)
|
|
|
|
|
{
|
|
|
|
|
int *fd = data, ret;
|
|
|
|
|
#ifdef NO_PTHREADS
|
|
|
|
|
close(fd[1]);
|
|
|
|
|
#endif
|
|
|
|
|
ret = recv_sideband("send-pack", fd[0], out);
|
|
|
|
|
close(out);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
int quiet_supported = 0;
|
|
|
|
|
int agent_supported = 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 (server_supports("quiet"))
|
|
|
|
|
quiet_supported = 1;
|
|
|
|
|
if (server_supports("agent"))
|
|
|
|
|
agent_supported = 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:
|
2012-11-30 02:41:37 +01:00
|
|
|
case REF_STATUS_REJECT_ALREADY_EXISTS:
|
push: introduce REJECT_FETCH_FIRST and REJECT_NEEDS_FORCE
When we push to update an existing ref, if:
* the object at the tip of the remote is not a commit; or
* the object we are pushing is not a commit,
it won't be correct to suggest to fetch, integrate and push again,
as the old and new objects will not "merge". We should explain that
the push must be forced when there is a non-committish object is
involved in such a case.
If we do not have the current object at the tip of the remote, we do
not even know that object, when fetched, is something that can be
merged. In such a case, suggesting to pull first just like
non-fast-forward case may not be technically correct, but in
practice, most such failures are seen when you try to push your work
to a branch without knowing that somebody else already pushed to
update the same branch since you forked, so "pull first" would work
as a suggestion most of the time. And if the object at the tip is
not a commit, "pull first" will fail, without making any permanent
damage. As a side effect, it also makes the error message the user
will get during the next "push" attempt easier to understand, now
the user is aware that a non-commit object is involved.
In these cases, the current code already rejects such a push on the
client end, but we used the same error and advice messages as the
ones used when rejecting a non-fast-forward push, i.e. pull from
there and integrate before pushing again.
Introduce new rejection reasons and reword the messages
appropriately.
[jc: with help by Peff on message details]
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-23 22:55:30 +01:00
|
|
|
case REF_STATUS_REJECT_FETCH_FIRST:
|
|
|
|
|
case REF_STATUS_REJECT_NEEDS_FORCE:
|
2013-07-08 23:42:40 +02:00
|
|
|
case REF_STATUS_REJECT_STALE:
|
2012-10-26 17:53:53 +02:00
|
|
|
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);
|
|
|
|
|
int quiet = quiet_supported && (args->quiet || !args->progress);
|
|
|
|
|
|
|
|
|
|
if (!cmds_sent && (status_report || use_sideband ||
|
|
|
|
|
quiet || agent_supported)) {
|
|
|
|
|
packet_buf_write(&req_buf,
|
|
|
|
|
"%s %s %s%c%s%s%s%s%s",
|
|
|
|
|
old_hex, new_hex, ref->name, 0,
|
|
|
|
|
status_report ? " report-status" : "",
|
|
|
|
|
use_sideband ? " side-band-64k" : "",
|
|
|
|
|
quiet ? " quiet" : "",
|
|
|
|
|
agent_supported ? " agent=" : "",
|
|
|
|
|
agent_supported ? git_user_agent_sanitized() : ""
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
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 {
|
2013-02-20 21:01:56 +01:00
|
|
|
write_or_die(out, req_buf.buf, req_buf.len);
|
2012-10-26 17:53:53 +02:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (new_refs && cmds_sent) {
|
|
|
|
|
if (pack_objects(out, remote_refs, extra_have, args) < 0) {
|
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next)
|
|
|
|
|
ref->status = REF_STATUS_NONE;
|
|
|
|
|
if (args->stateless_rpc)
|
|
|
|
|
close(out);
|
|
|
|
|
if (git_connection_is_socket(conn))
|
|
|
|
|
shutdown(fd[0], SHUT_WR);
|
|
|
|
|
if (use_sideband)
|
|
|
|
|
finish_async(&demux);
|
2013-10-22 15:36:02 +02:00
|
|
|
fd[1] = -1;
|
2012-10-26 17:53:53 +02:00
|
|
|
return -1;
|
|
|
|
|
}
|
2013-10-22 15:36:02 +02:00
|
|
|
if (!args->stateless_rpc)
|
|
|
|
|
/* Closed by pack_objects() via start_command() */
|
|
|
|
|
fd[1] = -1;
|
2012-10-26 17:53:53 +02:00
|
|
|
}
|
|
|
|
|
if (args->stateless_rpc && cmds_sent)
|
|
|
|
|
packet_flush(out);
|
|
|
|
|
|
|
|
|
|
if (status_report && cmds_sent)
|
|
|
|
|
ret = receive_status(in, remote_refs);
|
|
|
|
|
else
|
|
|
|
|
ret = 0;
|
|
|
|
|
if (args->stateless_rpc)
|
|
|
|
|
packet_flush(out);
|
|
|
|
|
|
|
|
|
|
if (use_sideband && cmds_sent) {
|
|
|
|
|
if (finish_async(&demux)) {
|
|
|
|
|
error("error in sideband demultiplexer");
|
|
|
|
|
ret = -1;
|
|
|
|
|
}
|
|
|
|
|
close(demux.out);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
if (args->porcelain)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next) {
|
|
|
|
|
switch (ref->status) {
|
|
|
|
|
case REF_STATUS_NONE:
|
|
|
|
|
case REF_STATUS_UPTODATE:
|
|
|
|
|
case REF_STATUS_OK:
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|