* Re: [PATCH] [BUG] Add a test to check git-prune does not throw away revs hidden by a graft.
From: Linus Torvalds @ 2006-05-18 22:01 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7viro3nh07.fsf@assigned-by-dhcp.cox.net>
On Thu, 18 May 2006, Junio C Hamano wrote:
>
> I haven't looked at what the test does, but I think he is
> talking about the opposite. fsck by design does not honor
> grafts, and if you grafted a history back to your true root
> commit, that "older" history will be lost.
Ahh. Ok. Gotcha.
Linus
^ permalink raw reply
* Re: [PATCH] [BUG] Add a test to check git-prune does not throw away revs hidden by a graft.
From: Yann Dirson @ 2006-05-18 22:20 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Linus Torvalds, git
In-Reply-To: <7viro3nh07.fsf@assigned-by-dhcp.cox.net>
On Thu, May 18, 2006 at 02:46:16PM -0700, Junio C Hamano wrote:
> Linus Torvalds <torvalds@osdl.org> writes:
>
> > Is it/does it?
> >
> > I'd assume that if you have a graft, you _want_ the history to be hidden
> > and pruned.
> >
> > That's how you'd drop history, if you wanted to do it on purpose.
>
> I haven't looked at what the test does, but I think he is
> talking about the opposite. fsck by design does not honor
> grafts, and if you grafted a history back to your true root
> commit, that "older" history will be lost.
I'm not sure I understand what you're saying. AFACT fsck does not
ignore grafts: if a rev is not accessible from heads because of a
graft, prune drops it, and fsck does not see a problem.
Linus, I understand your point, but the current situation is
problematic: a graft does not get propagated by cg-clone (and I
suppose not by git-clone or git-fetch either), so cloning a tree which
has undergone such a pruning operation results in an incomplete clone
(indeed it is how I met the problem). Since grafts are supposed to
have local effect only (as far as I understand), I see it as a bad
indication to have such a remote effect.
Maybe to make things safe, prune should by default consider both
physical and grafted parents as accessible, and a flag could be added
to get the current behaviour for people really knowing what they're
doing ?
Best regards,
--
Yann Dirson <ydirson@altern.org> |
Debian-related: <dirson@debian.org> | Support Debian GNU/Linux:
| Freedom, Power, Stability, Gratis
http://ydirson.free.fr/ | Check <http://www.debian.org/>
^ permalink raw reply
* Re: tailor (Was: gateway status?)
From: Martin Langhoff @ 2006-05-18 22:16 UTC (permalink / raw)
To: Yann Dirson; +Cc: David Lang, git
In-Reply-To: <20060518220759.GA6535@nowhere.earth>
On 5/19/06, Yann Dirson <ydirson@altern.org> wrote:
> Another tool that I don't see mentionned often here is tailor, which
> has the ability to act as a gatway between git and a good selection of
> other SCMs, including cvs and svn. I have not yet tried it with git
> though, so any comments from people having shaked it a bit would be
> useful :)
Last I looked, a few months ago, it didn't track branches.
cheers,
martin
^ permalink raw reply
* Re: [PATCH] [BUG] Add a test to check git-prune does not throw away revs hidden by a graft.
From: Junio C Hamano @ 2006-05-18 22:25 UTC (permalink / raw)
To: Linus Torvalds; +Cc: git, Yann Dirson
In-Reply-To: <Pine.LNX.4.64.0605181500470.10823@g5.osdl.org>
Linus Torvalds <torvalds@osdl.org> writes:
> On Thu, 18 May 2006, Junio C Hamano wrote:
>>
>> I haven't looked at what the test does, but I think he is
>> talking about the opposite. fsck by design does not honor
>> grafts, and if you grafted a history back to your true root
>> commit, that "older" history will be lost.
>
> Ahh. Ok. Gotcha.
>
> Linus
Is it really OK?
I said "fsck by design does not honor" as a flamebait.
And what I said was completely untrue. Sorry.
If you have a commit chain A->B->C and graft B away by saying
C's parent is A, fsck does read graft and discards B. But that
is what the user asked to do, so I agree with your initial
response to Yann.
And the opposite case of grafting older history back to the real
root commit was a false alarm. You would not lose such a
history, because the ancestry traversal will go right through
the real root and traverses the older history.
^ permalink raw reply
* Re: [PATCH] [BUG] Add a test to check git-prune does not throw away revs hidden by a graft.
From: Junio C Hamano @ 2006-05-18 22:36 UTC (permalink / raw)
To: Yann Dirson; +Cc: git
In-Reply-To: <20060518222045.GB6535@nowhere.earth>
Yann Dirson <ydirson@altern.org> writes:
> I'm not sure I understand what you're saying.
Please don't; I was asleep when I typed it -- sorry.
I was hoping fsck was doing the right thing for a very low level
tool -- verify commit objects itself, without relying on the
object parser machinery which does funky things like grafts.
Apparently it doesn't -- which is mostly good. You can safely
remove commits you wanted to discard by grafting it away like
your test did, and you can keep unrelated history you grafted to
the back of your real root commit.
For the "clone without propagating grafts" issue, I think we
need to have a way to communicate grafts across repositories.
As you say, grafts is a local policy issue, but when you start
cloning you _are_ sharing that local policy across repositories.
Futzing fsck to honor and ignore grafts at the same time sounds
like a band-aid to me.
^ permalink raw reply
* Re: [PATCH] [BUG] Add a test to check git-prune does not throw away revs hidden by a graft.
From: Yann Dirson @ 2006-05-18 22:52 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Linus Torvalds, git
In-Reply-To: <20060518222045.GB6535@nowhere.earth>
On Fri, May 19, 2006 at 12:20:45AM +0200, Yann Dirson wrote:
> On Thu, May 18, 2006 at 02:46:16PM -0700, Junio C Hamano wrote:
> > Linus Torvalds <torvalds@osdl.org> writes:
> >
> > > Is it/does it?
> > >
> > > I'd assume that if you have a graft, you _want_ the history to be hidden
> > > and pruned.
> > >
> > > That's how you'd drop history, if you wanted to do it on purpose.
> >
> > I haven't looked at what the test does, but I think he is
> > talking about the opposite. fsck by design does not honor
> > grafts, and if you grafted a history back to your true root
> > commit, that "older" history will be lost.
>
> I'm not sure I understand what you're saying. AFACT fsck does not
> ignore grafts: if a rev is not accessible from heads because of a
> graft, prune drops it, and fsck does not see a problem.
>
> Linus, I understand your point, but the current situation is
> problematic: a graft does not get propagated by cg-clone (and I
> suppose not by git-clone or git-fetch either), so cloning a tree which
> has undergone such a pruning operation results in an incomplete clone
> (indeed it is how I met the problem). Since grafts are supposed to
> have local effect only (as far as I understand), I see it as a bad
> indication to have such a remote effect.
To make my point maybe more clear: if someone really wants to make a
graft permanent, wouldn't some history rewriting (eg. with
cg-admin-rewritehist, but see the patch I posted against it) be the
way to go, instead of relying on out-of-band transfer of graft data ?
--
Yann Dirson <ydirson@altern.org> |
Debian-related: <dirson@debian.org> | Support Debian GNU/Linux:
| Freedom, Power, Stability, Gratis
http://ydirson.free.fr/ | Check <http://www.debian.org/>
^ permalink raw reply
* Re: [PATCH] [BUG] Add a test to check git-prune does not throw away revs hidden by a graft.
From: Junio C Hamano @ 2006-05-18 22:53 UTC (permalink / raw)
To: Yann Dirson; +Cc: git
In-Reply-To: <20060518225216.GC6535@nowhere.earth>
Yann Dirson <ydirson@altern.org> writes:
> To make my point maybe more clear: if someone really wants to make a
> graft permanent, wouldn't some history rewriting ... be the
> way to go,...
Yes.
^ permalink raw reply
* [PATCH] Allow pickaxe to be used via git log.
From: Sean @ 2006-05-19 1:31 UTC (permalink / raw)
To: git
Handle the -S option when passed to git log such that only the appropriate
commits are displayed. Unlike "whatchanged", by default no diff output
is produced.
---
This came out of recent comments on #git and will hopefully further reduce
the need for git-whatchanged.
ecdfaa21dbff93a6a387b02e1f1d3ebf05ee517d
revision.c | 7 +++++++
1 files changed, 7 insertions(+), 0 deletions(-)
ecdfaa21dbff93a6a387b02e1f1d3ebf05ee517d
diff --git a/revision.c b/revision.c
index 2294b16..2e18b2b 100644
--- a/revision.c
+++ b/revision.c
@@ -743,6 +743,13 @@ int setup_revisions(int argc, const char
continue;
}
opts = diff_opt_parse(&revs->diffopt, argv+i, argc-i);
+ if (revs->diffopt.pickaxe && revs->always_show_header) {
+ revs->always_show_header = 0;
+ revs->diff = 1;
+ revs->diffopt.recursive = 1;
+ if (revs->diffopt.output_format == DIFF_FORMAT_RAW)
+ revs->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT;
+ }
if (opts > 0) {
revs->diff = 1;
i += opts - 1;
--
1.3.GIT
^ permalink raw reply related
* Re: [PATCH] Allow pickaxe to be used via git log.
From: Junio C Hamano @ 2006-05-19 2:47 UTC (permalink / raw)
To: Sean; +Cc: git
In-Reply-To: <BAYC1-PASMTP04945C92FB14DA65AB1AC7AEA70@CEZ.ICE>
Sean <seanlkml@sympatico.ca> writes:
> Handle the -S option when passed to git log such that only the appropriate
> commits are displayed. Unlike "whatchanged", by default no diff output
> is produced.
If that (specifically, "when passed to git log") is what you
want, do all of that in "git log" please. I haven't checked,
but I suspect your changes would break git-rev-list and makes it
disobey the options the user gives it.
^ permalink raw reply
* Re: [PATCH] Allow pickaxe to be used via git log.
From: Sean @ 2006-05-19 2:56 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7v4pzmn32g.fsf@assigned-by-dhcp.cox.net>
On Thu, 18 May 2006 19:47:19 -0700
Junio C Hamano <junkio@cox.net> wrote:
> If that (specifically, "when passed to git log") is what you
> want, do all of that in "git log" please. I haven't checked,
> but I suspect your changes would break git-rev-list and makes it
> disobey the options the user gives it.
>
Well, it's more general than just git log, but that's primarily where one
would see it. Essentially the patch is saying that specifying both a
"revs->diffopt.pickaxe" string and "revs->always_show_header" is illegal
and proceeds to use pickaxe instead of the other.
Is there any place that depends on the ability to specify both a pickaxe
string _and_ always_show_header? If not, it's hard to see how this patch
could break anything.
Sean
^ permalink raw reply
* [PATCH] built-in tar-tree and remote tar-tree
From: Junio C Hamano @ 2006-05-19 3:03 UTC (permalink / raw)
To: git
In-Reply-To: <20060518192144.15912.qmail@web25913.mail.ukl.yahoo.com>
This makes tar-tree a built-in. As an added bonus, you can now
say:
git tar-tree --remote=remote-repository <ent> [<base>]
This does not work with git-daemon yet, but should work with
localhost and git over ssh transports.
Signed-off-by: Junio C Hamano <junkio@cox.net>
---
* It comes up every once in a while that somebody says he wants
a shallow clone, but when asked "what for?" it turns out that
what is wanted is the ability to download a tarball for a
specific revision for building that version, so here is one.
If people think this is a useful thing, we would need to
teach git-daemon about git-upload-tar, and perhaps we would
also want to compress the tar image while it goes over the
wire, which would be more work.
Makefile | 8 +++--
tar-tree.c => builtin-tar-tree.c | 62 +++++++++++++++++++++++++++++++++++-
builtin-upload-tar.c | 66 ++++++++++++++++++++++++++++++++++++++
builtin.h | 2 +
git.c | 2 +
5 files changed, 135 insertions(+), 5 deletions(-)
diff --git a/Makefile b/Makefile
index 2149fb8..caf1e70 100644
--- a/Makefile
+++ b/Makefile
@@ -161,7 +161,7 @@ PROGRAMS = \
git-receive-pack$X git-rev-parse$X \
git-send-pack$X git-show-branch$X git-shell$X \
git-show-index$X git-ssh-fetch$X \
- git-ssh-upload$X git-tar-tree$X git-unpack-file$X \
+ git-ssh-upload$X git-unpack-file$X \
git-unpack-objects$X git-update-index$X git-update-server-info$X \
git-upload-pack$X git-verify-pack$X git-write-tree$X \
git-update-ref$X git-symbolic-ref$X \
@@ -170,7 +170,8 @@ PROGRAMS = \
BUILT_INS = git-log$X git-whatchanged$X git-show$X \
git-count-objects$X git-diff$X git-push$X \
- git-grep$X git-rev-list$X git-check-ref-format$X
+ git-grep$X git-rev-list$X git-check-ref-format$X \
+ git-tar-tree$X git-upload-tar$X
# what 'all' will build and 'install' will install, in gitexecdir
ALL_PROGRAMS = $(PROGRAMS) $(SIMPLE_PROGRAMS) $(SCRIPTS)
@@ -218,7 +219,8 @@ LIB_OBJS = \
BUILTIN_OBJS = \
builtin-log.o builtin-help.o builtin-count.o builtin-diff.o builtin-push.o \
- builtin-grep.o builtin-rev-list.o builtin-check-ref-format.o
+ builtin-grep.o builtin-rev-list.o builtin-check-ref-format.o \
+ builtin-tar-tree.o builtin-upload-tar.o
GITLIBS = $(LIB_FILE) $(XDIFF_LIB)
LIBS = $(GITLIBS) -lz
diff --git a/tar-tree.c b/builtin-tar-tree.c
similarity index 86%
rename from tar-tree.c
rename to builtin-tar-tree.c
index 3308736..e97e0af 100644
--- a/tar-tree.c
+++ b/builtin-tar-tree.c
@@ -7,11 +7,14 @@ #include "tree-walk.h"
#include "commit.h"
#include "strbuf.h"
#include "tar.h"
+#include "builtin.h"
+#include "pkt-line.h"
#define RECORDSIZE (512)
#define BLOCKSIZE (RECORDSIZE * 20)
-static const char tar_tree_usage[] = "git-tar-tree <key> [basedir]";
+static const char tar_tree_usage[] =
+"git-tar-tree [--remote=<repo>] <ent> [basedir]";
static char block[BLOCKSIZE];
static unsigned long offset;
@@ -301,7 +304,7 @@ static void traverse_tree(struct tree_de
}
}
-int main(int argc, char **argv)
+int generate_tar(int argc, const char **argv)
{
unsigned char sha1[20], tree_sha1[20];
struct commit *commit;
@@ -348,3 +351,58 @@ int main(int argc, char **argv)
free(current_path.buf);
return 0;
}
+
+static const char *exec = "git-upload-tar";
+
+static int remote_tar(int argc, const char **argv)
+{
+ int fd[2], ret, len;
+ pid_t pid;
+ char buf[1024];
+ char *url;
+
+ if (argc < 3 || 4 < argc)
+ usage(tar_tree_usage);
+
+ /* --remote=<repo> */
+ url = strdup(argv[1]+9);
+ pid = git_connect(fd, url, exec);
+ if (pid < 0)
+ return 1;
+
+ packet_write(fd[1], "want %s\n", argv[2]);
+ if (argv[3])
+ packet_write(fd[1], "base %s\n", argv[3]);
+ packet_flush(fd[1]);
+
+ len = packet_read_line(fd[0], buf, sizeof(buf));
+ if (!len)
+ die("git-tar-tree: expected ACK/NAK, got EOF");
+ if (buf[len-1] == '\n')
+ buf[--len] = 0;
+ if (strcmp(buf, "ACK")) {
+ if (5 < len && !strncmp(buf, "NACK ", 5))
+ die("git-tar-tree: NACK %s", buf + 5);
+ die("git-tar-tree: protocol error");
+ }
+ /* expect a flush */
+ len = packet_read_line(fd[0], buf, sizeof(buf));
+ if (len)
+ die("git-tar-tree: expected a flush");
+
+ /* Now, start reading from fd[0] and spit it out to stdout */
+ ret = copy_fd(fd[0], 1);
+ close(fd[0]);
+
+ ret |= finish_connect(pid);
+ return !!ret;
+}
+
+int cmd_tar_tree(int argc, const char **argv, char **envp)
+{
+ if (argc < 2)
+ usage(tar_tree_usage);
+ if (!strncmp("--remote=", argv[1], 9))
+ return remote_tar(argc, argv);
+ return generate_tar(argc, argv);
+}
diff --git a/builtin-upload-tar.c b/builtin-upload-tar.c
new file mode 100644
index 0000000..883b5aa
--- /dev/null
+++ b/builtin-upload-tar.c
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2006 Junio C Hamano
+ */
+#include "cache.h"
+#include "pkt-line.h"
+#include "exec_cmd.h"
+#include "builtin.h"
+
+static const char upload_tar_usage[] = "git-upload-tar <repo>";
+
+static int nack(const char *reason)
+{
+ packet_write(1, "NACK %s\n", reason);
+ packet_flush(1);
+ return 1;
+}
+
+int cmd_upload_tar(int argc, const char **argv, char **envp)
+{
+ int len;
+ char *dir = argv[1];
+ char buf[8129];
+ unsigned char sha1[20];
+ char *base = NULL;
+ char hex[41];
+ int ac;
+ const char *av[4];
+
+ if (argc != 2)
+ usage(upload_tar_usage);
+ if (!enter_repo(dir, 0))
+ return nak("not a git archive", dir);
+ len = packet_read_line(0, buf, sizeof(buf));
+ if (len < 5 || strncmp("want ", buf, 5))
+ return nak("expected want");
+ if (buf[len-1] == '\n')
+ buf[--len] = 0;
+ if (get_sha1(buf + 5, sha1))
+ return nak("expected sha1");
+ strcpy(hex, sha1_to_hex(sha1));
+
+ len = packet_read_line(0, buf, sizeof(buf));
+ if (len) {
+ if (len < 5 || strncmp("base ", buf, 5))
+ return nak("expected (optional) base");
+ if (buf[len-1] == '\n')
+ buf[--len] = 0;
+ base = strdup(buf + 5);
+ len = packet_read_line(0, buf, sizeof(buf));
+ }
+ if (len)
+ return nak("expected flush");
+
+ packet_write(1, "ACK\n");
+ packet_flush(1);
+
+ ac = 0;
+ av[ac++] = "tar-tree";
+ av[ac++] = hex;
+ if (base)
+ av[ac++] = base;
+ av[ac++] = NULL;
+ execv_git_cmd(av);
+ /* should it return that is an error */
+ return 1;
+}
diff --git a/builtin.h b/builtin.h
index ff559de..3ed5d65 100644
--- a/builtin.h
+++ b/builtin.h
@@ -26,5 +26,7 @@ extern int cmd_push(int argc, const char
extern int cmd_grep(int argc, const char **argv, char **envp);
extern int cmd_rev_list(int argc, const char **argv, char **envp);
extern int cmd_check_ref_format(int argc, const char **argv, char **envp);
+extern int cmd_tar_tree(int argc, const char **argv, char **envp);
+extern int cmd_upload_tar(int argc, const char **argv, char **envp);
#endif
diff --git a/git.c b/git.c
index d0650bb..79d81b1 100644
--- a/git.c
+++ b/git.c
@@ -50,6 +50,8 @@ static void handle_internal_command(int
{ "count-objects", cmd_count_objects },
{ "diff", cmd_diff },
{ "grep", cmd_grep },
+ { "tar-tree", cmd_tar_tree },
+ { "upload-tar", cmd_upload_tar },
{ "rev-list", cmd_rev_list },
{ "check-ref-format", cmd_check_ref_format }
};
--
1.3.3.gfad60
^ permalink raw reply related
* Re: [PATCH] Allow pickaxe to be used via git log.
From: Junio C Hamano @ 2006-05-19 3:05 UTC (permalink / raw)
To: git
In-Reply-To: <BAYC1-PASMTP07581788E7BAAC19B2A159AEA70@CEZ.ICE>
Sean <seanlkml@sympatico.ca> writes:
> Is there any place that depends on the ability to specify both a pickaxe
> string _and_ always_show_header? If not, it's hard to see how this patch
> could break anything.
User's scripts. The point is the set of arguments rev-list as
the lowest level machinery should not be modified by an
arbitrary policy decision that happens to suit "git log" usage.
^ permalink raw reply
* Re: [PATCH] Allow pickaxe to be used via git log.
From: Junio C Hamano @ 2006-05-19 3:39 UTC (permalink / raw)
To: Sean; +Cc: git
In-Reply-To: <BAYC1-PASMTP04945C92FB14DA65AB1AC7AEA70@CEZ.ICE>
Sean <seanlkml@sympatico.ca> writes:
> Handle the -S option when passed to git log such that only the appropriate
> commits are displayed. Unlike "whatchanged", by default no diff output
> is produced.
If your goal is to make whatchanged less necessary, I think you
would need to special case --diff-filter as well for "git log",
although nobody on #git channel seems to have noticed. I often
run --diff-filter=A when I am trying to see when I added a
particular file, to avoid getting distracted by other types of
changes; log would be still shown if do not disable --always.
^ permalink raw reply
* Re: [PATCH] Allow pickaxe to be used via git log.
From: Sean @ 2006-05-19 3:38 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vk68ilnoi.fsf@assigned-by-dhcp.cox.net>
On Thu, 18 May 2006 20:05:01 -0700
Junio C Hamano <junkio@cox.net> wrote:
> User's scripts. The point is the set of arguments rev-list as
> the lowest level machinery should not be modified by an
> arbitrary policy decision that happens to suit "git log" usage.
>
Okay, thanks.
This moves the policy up a level and into the log/show/whatchanged code
and makes the code match the commit message better. However, it will still
"disobey" user options if the user tries to combine both pickaxe and
--always for these commands; but hopefully that's okay at this level.
Sean
diff --git a/builtin-log.c b/builtin-log.c
index d5bbc1c..d2c3df0 100644
--- a/builtin-log.c
+++ b/builtin-log.c
@@ -23,6 +23,11 @@ static int cmd_log_wc(int argc, const ch
rev->commit_format = CMIT_FMT_DEFAULT;
rev->verbose_header = 1;
argc = setup_revisions(argc, argv, rev, "HEAD");
+ if (rev->diffopt.pickaxe && rev->always_show_header) {
+ rev->always_show_header = 0;
+ if (rev->diffopt.output_format == DIFF_FORMAT_RAW)
+ rev->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT;
+ }
if (argc > 1)
die("unrecognized argument: %s", argv[1]);
^ permalink raw reply related
* [PATCH] Allow pickaxe and diff-filter options to be used by git log.
From: Sean @ 2006-05-19 4:19 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vac9elm2p.fsf@assigned-by-dhcp.cox.net>
Handle the -S option when passed to git log such that only the
appropriate commits are displayed. Also per Junio's comments, do
the same for "--diff-filter", so that it too can be used as an option
to git log. By default no patch or diff information is displayed.
Signed-off-by: Sean Estabrooks <seanlkml@sympatico.ca>
---
> If your goal is to make whatchanged less necessary, I think you
> would need to special case --diff-filter as well for "git log",
> although nobody on #git channel seems to have noticed. I often
> run --diff-filter=A when I am trying to see when I added a
> particular file, to avoid getting distracted by other types of
> changes; log would be still shown if do not disable --always.
Makes sense. This patch should cover that case too.
Sean
a2221c07a94bc378ef40182fa6b260ac88804073
builtin-log.c | 7 +++++++
1 files changed, 7 insertions(+), 0 deletions(-)
a2221c07a94bc378ef40182fa6b260ac88804073
diff --git a/builtin-log.c b/builtin-log.c
index d5bbc1c..12a6d19 100644
--- a/builtin-log.c
+++ b/builtin-log.c
@@ -23,6 +23,13 @@ static int cmd_log_wc(int argc, const ch
rev->commit_format = CMIT_FMT_DEFAULT;
rev->verbose_header = 1;
argc = setup_revisions(argc, argv, rev, "HEAD");
+ if (rev->always_show_header) {
+ if (rev->diffopt.pickaxe || rev->diffopt.filter) {
+ rev->always_show_header = 0;
+ if (rev->diffopt.output_format == DIFF_FORMAT_RAW)
+ rev->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT;
+ }
+ }
if (argc > 1)
die("unrecognized argument: %s", argv[1]);
--
1.3.GIT
^ permalink raw reply related
* Re: [PATCH] Allow pickaxe and diff-filter options to be used by git log.
From: Junio C Hamano @ 2006-05-19 5:41 UTC (permalink / raw)
To: Sean; +Cc: git
In-Reply-To: <BAYC1-PASMTP096010F052E9BF78B5FD4AAEA70@CEZ.ICE>
Sean <seanlkml@sympatico.ca> writes:
> + if (rev->always_show_header) {
> + if (rev->diffopt.pickaxe || rev->diffopt.filter) {
I understand and agree to the change up to this part, but I do
not necessarily agree with what follows:
> + rev->always_show_header = 0;
> + if (rev->diffopt.output_format == DIFF_FORMAT_RAW)
> + rev->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT;
To me, if the user explicitly says --diff-filter or -S, it seems
more natural to interpret that the user wanted _some_ sort of
diff. Now, there are people who say raw format is anti-human,
which I consider is a valid view, but I think it is better than
NO_OUTPUT in that case.
I wonder if doing something like this instead makes more sense
perhaps?
-- >8 --
diff --git a/builtin-log.c b/builtin-log.c
index 69f2911..e68bfad 100644
--- a/builtin-log.c
+++ b/builtin-log.c
@@ -23,6 +23,35 @@ static int cmd_log_wc(int argc, const ch
if (argc > 1)
die("unrecognized argument: %s", argv[1]);
+ if (rev->always_show_header) {
+ /* Log command is primarily about the message for human
+ * consumption, but if the user asks for any diff, it
+ * is human unfriendly to give the raw diff.
+ *
+ * Show command is the same way, but there the default is
+ * always give patch output, so this does not trigger.
+ */
+ if (rev->diffopt.output_format == DIFF_FORMAT_RAW) {
+ if (rev->diffopt.pickaxe)
+ rev->diffopt.output_format = DIFF_FORMAT_PATCH;
+ else {
+ rev->diffopt.output_format = DIFF_FORMAT_DIFFSTAT;
+ rev->diffopt.summary = 1;
+ }
+ }
+
+ /* If the user is limiting the commits to the ones
+ * that have particular classes of diff, we should not
+ * show the log message for irrelevant ones.
+ *
+ * git show --diff-filter=R -M --all can be used to view
+ * the branch tips that renames something. I do not know
+ * how useful that is, though.
+ */
+ if (rev->diffopt.pickaxe || rev->diffopt.filter)
+ rev->always_show_header = 0;
+ }
+
prepare_revision_walk(rev);
setup_pager();
while ((commit = get_revision(rev)) != NULL) {
^ permalink raw reply related
* Re: [PATCH] built-in tar-tree and remote tar-tree
From: Junio C Hamano @ 2006-05-19 5:50 UTC (permalink / raw)
To: git
In-Reply-To: <7vodxulnqx.fsf_-_@assigned-by-dhcp.cox.net>
Sorry for sending a crapoid that does not even compile. I ran
format-patch while on a wrong branch.
Tonight's "pu" will have a fixed up one for people who are
interested to play with.
^ permalink raw reply
* Re: [PATCH] Allow pickaxe and diff-filter options to be used by git log.
From: Sean @ 2006-05-19 5:49 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vbqtuk1uw.fsf@assigned-by-dhcp.cox.net>
On Thu, 18 May 2006 22:41:43 -0700
Junio C Hamano <junkio@cox.net> wrote:
> To me, if the user explicitly says --diff-filter or -S, it seems
> more natural to interpret that the user wanted _some_ sort of
> diff. Now, there are people who say raw format is anti-human,
> which I consider is a valid view, but I think it is better than
> NO_OUTPUT in that case.
>
> I wonder if doing something like this instead makes more sense
> perhaps?
Well, I was looking at the use of diff-filter and -S as a way
to prune uninteresting commits from the log rather than as an
desire to see the patch information.
It's pretty natural to add -p or --stat along with the above
options if that is what the user wants. If you make those implied
by using --diff-filter or -S is there a way for the user to say,
no patch and no stat?
Sean
^ permalink raw reply
* Re: [PATCH] Allow pickaxe and diff-filter options to be used by git log.
From: Junio C Hamano @ 2006-05-19 6:05 UTC (permalink / raw)
To: Sean; +Cc: git
In-Reply-To: <BAYC1-PASMTP092CB0667E05EA20FBA30EAEA70@CEZ.ICE>
Sean <seanlkml@sympatico.ca> writes:
> Well, I was looking at the use of diff-filter and -S as a way
> to prune uninteresting commits from the log rather than as an
> desire to see the patch information.
Fair enough.
> It's pretty natural to add -p or --stat along with the above
> options if that is what the user wants. If you make those implied
> by using --diff-filter or -S is there a way for the user to say,
> no patch and no stat?
Well, I was sneaking in a hidden feature with that tweak.
Regardless of the diff-filter/-S issues, with that alternative
patch, you could do:
$ git log -r
It lets you do a wonderful thing with surprisingly small number
of keystrokes ;-).
^ permalink raw reply
* FIXED: [WARNING] Please be careful when using "git add" from "next" branch
From: Junio C Hamano @ 2006-05-19 6:28 UTC (permalink / raw)
To: git; +Cc: linux-kernel
In-Reply-To: <7vsln74sv7.fsf_-_@assigned-by-dhcp.cox.net>
Junio C Hamano <junkio@cox.net> writes:
> There is still a small breakage in the built-in "git add" on the
> "next" branch that ends up creating nonsense tree objects.
This was fixed this morning, in case I scared people.
^ permalink raw reply
* [PATCH 0/5] Ref log updates
From: Shawn Pearce @ 2006-05-19 7:27 UTC (permalink / raw)
To: Junio Hamano; +Cc: git
The following series of patches applies on top of 'pu' and my prior
series of ref log related patches.
Most of these are bug fixes and test cases.
* [PATCH 1/5] General ref log reading improvements.
Performance improvements and minor bug fixes in the log
parser.
* [PATCH 2/5] Added logs/ directory to repository layout.
Minor documentation update that I missed in the last round.
* [PATCH 3/5] Force writing ref if it doesn't exist.
If a ref doesn't exist make sure we write it anyway.
I found a few cases were we weren't writing the ref; this
appears to have it fixed.
* [PATCH 4/5] Log ref updates made by fetch.
Fully enable ref logging for the *-fetch family of tools.
* [PATCH 5/5] Change 'master@noon' syntax to 'master@{noon}'.
Support parsing ':' in date strings correctly, especially
in the face of 'master@2005-06-12 16:12:foo'.
--
Shawn.
^ permalink raw reply
* [PATCH 1/5] General ref log reading improvements.
From: Shawn Pearce @ 2006-05-19 7:28 UTC (permalink / raw)
To: Junio Hamano; +Cc: git
Corrected the log starting time displayed in the error message
(as it was always showing the epoch due to a bad input to strtoul).
Improved the log parser so we only scan backwards towards the
'\n' from the end of the prior log; during this scan the last '>'
is remembered to improve performance (rather than scanning forward
to it).
If the log record matched is the last log record in the file only
use its new sha1 value if the date matches exactly; otherwise we
leave the passed in sha1 alone as it already contains the current
value of the ref. This way lookups of dates later than the log
end to stick with the current ref value in case the ref was updated
without logging.
If it looks like someone changed the ref without logging it and we
are going to return the sha1 which should have been valid during
the missing period then warn the user that there might be log data
missing and thus their query result may not be accurate. The check
isn't perfect as its just based on comparing the old and new sha1
values between the two log records but its better than not checking
at all.
Implemented test cases based on git-rev-parse for most of the
boundary conditions.
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
---
refs.c | 54 +++++++++++++++++++++++++++++++----------
t/t1400-update-ref.sh | 64 +++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 104 insertions(+), 14 deletions(-)
mode change 100644 => 100755 t/t1400-update-ref.sh
54717d099405378da50cd3d4715c1e5d6d793d68
diff --git a/refs.c b/refs.c
index ae9825d..9d37a02 100644
--- a/refs.c
+++ b/refs.c
@@ -432,11 +432,12 @@ int write_ref_sha1(struct ref_lock *lock
int read_ref_at(const char *ref, unsigned long at_time, unsigned char *sha1)
{
- const char *logfile, *logdata, *logend, *rec, *c;
+ const char *logfile, *logdata, *logend, *rec, *lastgt, *lastrec;
char *tz_c;
int logfd, tz;
struct stat st;
unsigned long date;
+ unsigned char logged_sha1[20];
logfile = git_path("logs/%s", ref);
logfd = open(logfile, O_RDONLY, 0);
@@ -448,32 +449,57 @@ int read_ref_at(const char *ref, unsigne
logdata = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, logfd, 0);
close(logfd);
+ lastrec = NULL;
rec = logend = logdata + st.st_size;
while (logdata < rec) {
if (logdata < rec && *(rec-1) == '\n')
rec--;
- while (logdata < rec && *(rec-1) != '\n')
+ lastgt = NULL;
+ while (logdata < rec && *(rec-1) != '\n') {
rec--;
- c = rec;
- while (c < logend && *c != '>' && *c != '\n')
- c++;
- if (c == logend || *c == '\n')
+ if (*rec == '>')
+ lastgt = rec;
+ }
+ if (!lastgt)
die("Log %s is corrupt.", logfile);
- date = strtoul(c + 1, NULL, 10);
+ date = strtoul(lastgt + 1, &tz_c, 10);
if (date <= at_time) {
- if (get_sha1_hex(rec + 41, sha1))
- die("Log %s is corrupt.", logfile);
+ if (lastrec) {
+ if (get_sha1_hex(lastrec, logged_sha1))
+ die("Log %s is corrupt.", logfile);
+ if (get_sha1_hex(rec + 41, sha1))
+ die("Log %s is corrupt.", logfile);
+ if (memcmp(logged_sha1, sha1, 20)) {
+ tz = strtoul(tz_c, NULL, 10);
+ fprintf(stderr,
+ "warning: Log %s has gap after %s.\n",
+ logfile, show_rfc2822_date(date, tz));
+ }
+ } else if (date == at_time) {
+ if (get_sha1_hex(rec + 41, sha1))
+ die("Log %s is corrupt.", logfile);
+ } else {
+ if (get_sha1_hex(rec + 41, logged_sha1))
+ die("Log %s is corrupt.", logfile);
+ if (memcmp(logged_sha1, sha1, 20)) {
+ tz = strtoul(tz_c, NULL, 10);
+ fprintf(stderr,
+ "warning: Log %s unexpectedly ended on %s.\n",
+ logfile, show_rfc2822_date(date, tz));
+ }
+ }
munmap((void*)logdata, st.st_size);
return 0;
}
+ lastrec = rec;
}
- c = logdata;
- while (c < logend && *c != '>' && *c != '\n')
- c++;
- if (c == logend || *c == '\n')
+ rec = logdata;
+ while (rec < logend && *rec != '>' && *rec != '\n')
+ rec++;
+ if (rec == logend || *rec == '\n')
die("Log %s is corrupt.", logfile);
- date = strtoul(c, &tz_c, 10);
+ date = strtoul(rec + 1, &tz_c, 10);
tz = strtoul(tz_c, NULL, 10);
if (get_sha1_hex(logdata, sha1))
die("Log %s is corrupt.", logfile);
diff --git a/t/t1400-update-ref.sh b/t/t1400-update-ref.sh
old mode 100644
new mode 100755
index f338c53..7858d86
--- a/t/t1400-update-ref.sh
+++ b/t/t1400-update-ref.sh
@@ -9,6 +9,10 @@ test_description='Test git-update-ref an
Z=0000000000000000000000000000000000000000
A=1111111111111111111111111111111111111111
B=2222222222222222222222222222222222222222
+C=3333333333333333333333333333333333333333
+D=4444444444444444444444444444444444444444
+E=5555555555555555555555555555555555555555
+F=6666666666666666666666666666666666666666
m=refs/heads/master
test_expect_success \
@@ -109,4 +113,64 @@ test_expect_success \
'diff expect .git/logs/$m'
rm -f .git/$m .git/logs/$m expect
+git-update-ref $m $D
+cat >.git/logs/$m <<EOF
+$C $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150320 -0500
+$A $B $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150380 -0500
+$F $Z $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150680 -0500
+$Z $E $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150980 -0500
+EOF
+
+ed="Thu, 26 May 2005 18:32:00 -0500"
+gd="Thu, 26 May 2005 18:33:00 -0500"
+ld="Thu, 26 May 2005 18:43:00 -0500"
+test_expect_success \
+ 'Query "master@May 25 2005" (before history)' \
+ 'rm -f o e
+ git-rev-parse --verify "master@May 25 2005" >o 2>e &&
+ test $C = $(cat o) &&
+ test "warning: Log .git/logs/$m only goes back to $ed." = "$(cat e)"'
+test_expect_success \
+ "Query master@2005-05-25 (before history)" \
+ 'rm -f o e
+ git-rev-parse --verify master@2005-05-25 >o 2>e &&
+ test $C = $(cat o) &&
+ echo test "warning: Log .git/logs/$m only goes back to $ed." = "$(cat e)"'
+test_expect_success \
+ 'Query "master@May 26 2005 23:31:59" (1 second before history)' \
+ 'rm -f o e
+ git-rev-parse --verify "master@May 26 2005 23:31:59" >o 2>e &&
+ test $C = $(cat o) &&
+ test "warning: Log .git/logs/$m only goes back to $ed." = "$(cat e)"'
+test_expect_success \
+ 'Query "master@May 26 2005 23:32:00" (exactly history start)' \
+ 'rm -f o e
+ git-rev-parse --verify "master@May 26 2005 23:32:00" >o 2>e &&
+ test $A = $(cat o) &&
+ test "" = "$(cat e)"'
+test_expect_success \
+ 'Query "master@2005-05-26 23:33:01" (middle of history with gap)' \
+ 'rm -f o e
+ git-rev-parse --verify "master@2005-05-26 23:33:01" >o 2>e &&
+ test $B = $(cat o) &&
+ test "warning: Log .git/logs/$m has gap after $gd." = "$(cat e)"'
+test_expect_success \
+ 'Query "master@2005-05-26 23:33:01" (middle of history)' \
+ 'rm -f o e
+ git-rev-parse --verify "master@2005-05-26 23:38:00" >o 2>e &&
+ test $Z = $(cat o) &&
+ test "" = "$(cat e)"'
+test_expect_success \
+ 'Query "master@2005-05-26 23:43:00" (exact end of history)' \
+ 'rm -f o e
+ git-rev-parse --verify "master@2005-05-26 23:43:00" >o 2>e &&
+ test $E = $(cat o) &&
+ test "" = "$(cat e)"'
+test_expect_success \
+ 'Query "master@2005-05-28" (past end of history)' \
+ 'rm -f o e
+ git-rev-parse --verify "master@2005-05-28" >o 2>e &&
+ test $D = $(cat o) &&
+ test "warning: Log .git/logs/$m unexpectedly ended on $ld." = "$(cat e)"'
+
test_done
--
1.3.2.g7278
^ permalink raw reply related
* [PATCH 2/5] Added logs/ directory to repository layout.
From: Shawn Pearce @ 2006-05-19 7:28 UTC (permalink / raw)
To: Junio Hamano; +Cc: git
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
---
Documentation/repository-layout.txt | 11 +++++++++++
1 files changed, 11 insertions(+), 0 deletions(-)
27faccbeae368625d4a11788e5cedc7b3dc23f54
diff --git a/Documentation/repository-layout.txt b/Documentation/repository-layout.txt
index 98fbe7d..b52dfdc 100644
--- a/Documentation/repository-layout.txt
+++ b/Documentation/repository-layout.txt
@@ -128,3 +128,14 @@ remotes::
Stores shorthands to be used to give URL and default
refnames to interact with remote repository to `git
fetch`, `git pull` and `git push` commands.
+
+logs::
+ Records of changes made to refs are stored in this
+ directory. See the documentation on git-update-ref
+ for more information.
+
+logs/refs/heads/`name`::
+ Records all changes made to the branch tip named `name`.
+
+logs/refs/tags/`name`::
+ Records all changes made to the tag named `name`.
--
1.3.2.g7278
^ permalink raw reply related
* [PATCH 3/5] Force writing ref if it doesn't exist.
From: Shawn Pearce @ 2006-05-19 7:29 UTC (permalink / raw)
To: Junio Hamano; +Cc: git
Normally we try to skip writing a ref if its value hasn't changed
but in the special case that the ref doesn't exist but the new
value is going to be 0{40} then force writing the ref anyway.
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
---
refs.c | 4 +++-
refs.h | 1 +
2 files changed, 4 insertions(+), 1 deletions(-)
13f3c9a2b8959da1947e21c32e58d81d32a83f3e
diff --git a/refs.c b/refs.c
index 9d37a02..31cf276 100644
--- a/refs.c
+++ b/refs.c
@@ -288,6 +288,7 @@ static struct ref_lock* lock_ref_sha1_ba
const unsigned char *old_sha1, int mustexist)
{
struct ref_lock *lock;
+ struct stat st;
lock = xcalloc(1, sizeof(struct ref_lock));
lock->lock_fd = -1;
@@ -303,6 +304,7 @@ static struct ref_lock* lock_ref_sha1_ba
lock->ref_file = strdup(path);
lock->lock_file = strdup(mkpath("%s.lock", lock->ref_file));
lock->log_file = strdup(git_path("logs/%s", lock->ref_file + plen));
+ lock->force_write = !lstat(lock->ref_file, &st) || errno == ENOENT;
if (safe_create_leading_directories(lock->lock_file))
die("unable to create directory for %s", lock->lock_file);
@@ -405,7 +407,7 @@ int write_ref_sha1(struct ref_lock *lock
if (!lock)
return -1;
- if (!memcmp(lock->old_sha1, sha1, 20)) {
+ if (!lock->force_write && !memcmp(lock->old_sha1, sha1, 20)) {
unlock_ref(lock);
return 0;
}
diff --git a/refs.h b/refs.h
index 2c854de..6c946ea 100644
--- a/refs.h
+++ b/refs.h
@@ -7,6 +7,7 @@ struct ref_lock {
char *log_file;
unsigned char old_sha1[20];
int lock_fd;
+ int force_write;
};
/*
--
1.3.2.g7278
^ permalink raw reply related
* [PATCH 4/5] Log ref updates made by fetch.
From: Shawn Pearce @ 2006-05-19 7:29 UTC (permalink / raw)
To: Junio Hamano; +Cc: git
If a ref is changed by http-fetch, local-fetch or ssh-fetch
record the change and the remote URL/name in the log for the ref.
This requires loading the config file to check logAllRefUpdates.
Also fixed a bug in the ref lock generation; the log file name was
not being produced right due to a bad prefix length.
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
---
fetch.c | 17 +++++++++++++++--
fetch.h | 3 +++
http-fetch.c | 2 ++
local-fetch.c | 2 ++
refs.c | 5 +++--
ssh-fetch.c | 2 ++
6 files changed, 27 insertions(+), 4 deletions(-)
b929e2a5a8f80c8635cf3c54a6d766902cf87434
diff --git a/fetch.c b/fetch.c
index 8bdaacb..fd57684 100644
--- a/fetch.c
+++ b/fetch.c
@@ -8,6 +8,7 @@ #include "blob.h"
#include "refs.h"
const char *write_ref = NULL;
+const char *write_ref_log_details = NULL;
const unsigned char *current_ref = NULL;
@@ -206,13 +207,17 @@ int pull(char *target)
{
struct ref_lock *lock;
unsigned char sha1[20];
+ char *msg;
+ int ret;
save_commit_buffer = 0;
track_object_refs = 0;
if (write_ref) {
lock = lock_ref_sha1(write_ref, current_ref, 1);
- if (!lock)
+ if (!lock) {
+ error("Can't lock ref %s", write_ref);
return -1;
+ }
}
if (!get_recover) {
@@ -234,7 +239,15 @@ int pull(char *target)
}
if (write_ref) {
- return write_ref_sha1(lock, sha1, "git fetch");
+ if (write_ref_log_details) {
+ msg = xmalloc(strlen(write_ref_log_details) + 12);
+ sprintf(msg, "fetch from %s", write_ref_log_details);
+ } else
+ msg = NULL;
+ ret = write_ref_sha1(lock, sha1, msg ? msg : "fetch (unknown)");
+ if (msg)
+ free(msg);
+ return ret;
}
return 0;
}
diff --git a/fetch.h b/fetch.h
index 9837a3d..0011548 100644
--- a/fetch.h
+++ b/fetch.h
@@ -25,6 +25,9 @@ extern int fetch_ref(char *ref, unsigned
/* If set, the ref filename to write the target value to. */
extern const char *write_ref;
+/* If set additional text will appear in the ref log. */
+extern const char *write_ref_log_details;
+
/* If set, the hash that the current value of write_ref must be. */
extern const unsigned char *current_ref;
diff --git a/http-fetch.c b/http-fetch.c
index 861644b..cc7bd1f 100644
--- a/http-fetch.c
+++ b/http-fetch.c
@@ -1223,6 +1223,7 @@ int main(int argc, char **argv)
int rc = 0;
setup_git_directory();
+ git_config(git_default_config);
while (arg < argc && argv[arg][0] == '-') {
if (argv[arg][1] == 't') {
@@ -1249,6 +1250,7 @@ int main(int argc, char **argv)
}
commit_id = argv[arg];
url = argv[arg + 1];
+ write_ref_log_details = url;
http_init();
diff --git a/local-fetch.c b/local-fetch.c
index fa9e697..ffa4887 100644
--- a/local-fetch.c
+++ b/local-fetch.c
@@ -208,6 +208,7 @@ int main(int argc, char **argv)
int arg = 1;
setup_git_directory();
+ git_config(git_default_config);
while (arg < argc && argv[arg][0] == '-') {
if (argv[arg][1] == 't')
@@ -239,6 +240,7 @@ int main(int argc, char **argv)
usage(local_pull_usage);
commit_id = argv[arg];
path = argv[arg + 1];
+ write_ref_log_details = path;
if (pull(commit_id))
return 1;
diff --git a/refs.c b/refs.c
index 31cf276..d3ddc82 100644
--- a/refs.c
+++ b/refs.c
@@ -142,6 +142,8 @@ static int do_for_each_ref(const char *b
namelen = strlen(de->d_name);
if (namelen > 255)
continue;
+ if (namelen>5 && !strcmp(de->d_name+namelen-5,".lock"))
+ continue;
memcpy(path + baselen, de->d_name, namelen+1);
if (stat(git_path("%s", path), &st) < 0)
continue;
@@ -296,7 +298,6 @@ static struct ref_lock* lock_ref_sha1_ba
plen = strlen(path) - plen;
path = resolve_ref(path, lock->old_sha1, mustexist);
if (!path) {
- error("Can't read ref %s", path);
unlock_ref(lock);
return NULL;
}
@@ -326,7 +327,7 @@ struct ref_lock* lock_ref_sha1(const cha
if (check_ref_format(ref))
return NULL;
return lock_ref_sha1_basic(git_path("refs/%s", ref),
- strlen(ref), old_sha1, mustexist);
+ 5 + strlen(ref), old_sha1, mustexist);
}
struct ref_lock* lock_any_ref_for_update(const char *ref,
diff --git a/ssh-fetch.c b/ssh-fetch.c
index 4eb9e04..e3067b8 100644
--- a/ssh-fetch.c
+++ b/ssh-fetch.c
@@ -132,6 +132,7 @@ int main(int argc, char **argv)
if (!prog) prog = "git-ssh-upload";
setup_git_directory();
+ git_config(git_default_config);
while (arg < argc && argv[arg][0] == '-') {
if (argv[arg][1] == 't') {
@@ -158,6 +159,7 @@ int main(int argc, char **argv)
}
commit_id = argv[arg];
url = argv[arg + 1];
+ write_ref_log_details = url;
if (setup_connection(&fd_in, &fd_out, prog, url, arg, argv + 1))
return 1;
--
1.3.2.g7278
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox