1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47 package org.eclipse.jgit.transport;
48
49 import java.io.IOException;
50 import java.io.InputStream;
51 import java.text.MessageFormat;
52 import java.util.ArrayList;
53 import java.util.Arrays;
54 import java.util.Collections;
55 import java.util.EnumSet;
56 import java.util.LinkedHashSet;
57 import java.util.List;
58 import java.util.Set;
59
60 import org.eclipse.jgit.errors.NoRemoteRepositoryException;
61 import org.eclipse.jgit.errors.NotSupportedException;
62 import org.eclipse.jgit.errors.TransportException;
63 import org.eclipse.jgit.internal.JGitText;
64 import org.eclipse.jgit.lib.Constants;
65 import org.eclipse.jgit.lib.Repository;
66 import org.eclipse.jgit.util.QuotedString;
67 import org.eclipse.jgit.util.SystemReader;
68 import org.eclipse.jgit.util.io.MessageWriter;
69 import org.eclipse.jgit.util.io.StreamCopyThread;
70 import org.eclipse.jgit.util.FS;
71
72
73
74
75
76
77
78
79
80
81
82
83 public class TransportGitSsh extends SshTransport implements PackTransport {
84 static final TransportProtocol PROTO_SSH = new TransportProtocol() {
85 private final String[] schemeNames = { "ssh", "ssh+git", "git+ssh" };
86
87 private final Set<String> schemeSet = Collections
88 .unmodifiableSet(new LinkedHashSet<String>(Arrays
89 .asList(schemeNames)));
90
91 public String getName() {
92 return JGitText.get().transportProtoSSH;
93 }
94
95 public Set<String> getSchemes() {
96 return schemeSet;
97 }
98
99 public Set<URIishField> getRequiredFields() {
100 return Collections.unmodifiableSet(EnumSet.of(URIishField.HOST,
101 URIishField.PATH));
102 }
103
104 public Set<URIishField> getOptionalFields() {
105 return Collections.unmodifiableSet(EnumSet.of(URIishField.USER,
106 URIishField.PASS, URIishField.PORT));
107 }
108
109 public int getDefaultPort() {
110 return 22;
111 }
112
113 @Override
114 public boolean canHandle(URIish uri, Repository local, String remoteName) {
115 if (uri.getScheme() == null) {
116
117 return uri.getHost() != null
118 && uri.getPath() != null
119 && uri.getHost().length() != 0
120 && uri.getPath().length() != 0;
121 }
122 return super.canHandle(uri, local, remoteName);
123 }
124
125 public Transport open(URIish uri, Repository local, String remoteName)
126 throws NotSupportedException {
127 return new TransportGitSsh(local, uri);
128 }
129
130 @Override
131 public Transport open(URIish uri) throws NotSupportedException, TransportException {
132 return new TransportGitSsh(uri);
133 }
134 };
135
136 TransportGitSsh(final Repository local, final URIish uri) {
137 super(local, uri);
138 initSshSessionFactory();
139 }
140
141 TransportGitSsh(final URIish uri) {
142 super(uri);
143 initSshSessionFactory();
144 }
145
146 private void initSshSessionFactory() {
147 if (useExtSession()) {
148 setSshSessionFactory(new SshSessionFactory() {
149 @Override
150 public RemoteSession getSession(URIish uri2,
151 CredentialsProvider credentialsProvider, FS fs, int tms)
152 throws TransportException {
153 return new ExtSession();
154 }
155 });
156 }
157 }
158
159 @Override
160 public FetchConnection openFetch() throws TransportException {
161 return new SshFetchConnection();
162 }
163
164 @Override
165 public PushConnection openPush() throws TransportException {
166 return new SshPushConnection();
167 }
168
169 String commandFor(final String exe) {
170 String path = uri.getPath();
171 if (uri.getScheme() != null && uri.getPath().startsWith("/~"))
172 path = (uri.getPath().substring(1));
173
174 final StringBuilder cmd = new StringBuilder();
175 cmd.append(exe);
176 cmd.append(' ');
177 cmd.append(QuotedString.BOURNE.quote(path));
178 return cmd.toString();
179 }
180
181 void checkExecFailure(int status, String exe, String why)
182 throws TransportException {
183 if (status == 127) {
184 IOException cause = null;
185 if (why != null && why.length() > 0)
186 cause = new IOException(why);
187 throw new TransportException(uri, MessageFormat.format(
188 JGitText.get().cannotExecute, commandFor(exe)), cause);
189 }
190 }
191
192 NoRemoteRepositoryException cleanNotFound(NoRemoteRepositoryException nf,
193 String why) {
194 if (why == null || why.length() == 0)
195 return nf;
196
197 String path = uri.getPath();
198 if (uri.getScheme() != null && uri.getPath().startsWith("/~"))
199 path = uri.getPath().substring(1);
200
201 final StringBuilder pfx = new StringBuilder();
202 pfx.append("fatal: ");
203 pfx.append(QuotedString.BOURNE.quote(path));
204 pfx.append(": ");
205 if (why.startsWith(pfx.toString()))
206 why = why.substring(pfx.length());
207
208 return new NoRemoteRepositoryException(uri, why);
209 }
210
211 private static boolean useExtSession() {
212 return SystemReader.getInstance().getenv("GIT_SSH") != null;
213 }
214
215 private class ExtSession implements RemoteSession {
216 public Process exec(String command, int timeout)
217 throws TransportException {
218 String ssh = SystemReader.getInstance().getenv("GIT_SSH");
219 boolean putty = ssh.toLowerCase().contains("plink");
220
221 List<String> args = new ArrayList<String>();
222 args.add(ssh);
223 if (putty && !ssh.toLowerCase().contains("tortoiseplink"))
224 args.add("-batch");
225 if (0 < getURI().getPort()) {
226 args.add(putty ? "-P" : "-p");
227 args.add(String.valueOf(getURI().getPort()));
228 }
229 if (getURI().getUser() != null)
230 args.add(getURI().getUser() + "@" + getURI().getHost());
231 else
232 args.add(getURI().getHost());
233 args.add(command);
234
235 ProcessBuilder pb = new ProcessBuilder();
236 pb.command(args);
237
238 if (local.getDirectory() != null)
239 pb.environment().put(Constants.GIT_DIR_KEY,
240 local.getDirectory().getPath());
241
242 try {
243 return pb.start();
244 } catch (IOException err) {
245 throw new TransportException(err.getMessage(), err);
246 }
247 }
248
249 public void disconnect() {
250
251 }
252 }
253
254 class SshFetchConnection extends BasePackFetchConnection {
255 private final Process process;
256
257 private StreamCopyThread errorThread;
258
259 SshFetchConnection() throws TransportException {
260 super(TransportGitSsh.this);
261 try {
262 process = getSession().exec(commandFor(getOptionUploadPack()),
263 getTimeout());
264 final MessageWriter msg = new MessageWriter();
265 setMessageWriter(msg);
266
267 final InputStream upErr = process.getErrorStream();
268 errorThread = new StreamCopyThread(upErr, msg.getRawStream());
269 errorThread.start();
270
271 init(process.getInputStream(), process.getOutputStream());
272
273 } catch (TransportException err) {
274 close();
275 throw err;
276 } catch (IOException err) {
277 close();
278 throw new TransportException(uri,
279 JGitText.get().remoteHungUpUnexpectedly, err);
280 }
281
282 try {
283 readAdvertisedRefs();
284 } catch (NoRemoteRepositoryException notFound) {
285 final String msgs = getMessages();
286 checkExecFailure(process.exitValue(), getOptionUploadPack(),
287 msgs);
288 throw cleanNotFound(notFound, msgs);
289 }
290 }
291
292 @Override
293 public void close() {
294 endOut();
295
296 if (errorThread != null) {
297 try {
298 errorThread.halt();
299 } catch (InterruptedException e) {
300
301 } finally {
302 errorThread = null;
303 }
304 }
305
306 super.close();
307 if (process != null)
308 process.destroy();
309 }
310 }
311
312 class SshPushConnection extends BasePackPushConnection {
313 private final Process process;
314
315 private StreamCopyThread errorThread;
316
317 SshPushConnection() throws TransportException {
318 super(TransportGitSsh.this);
319 try {
320 process = getSession().exec(commandFor(getOptionReceivePack()),
321 getTimeout());
322 final MessageWriter msg = new MessageWriter();
323 setMessageWriter(msg);
324
325 final InputStream rpErr = process.getErrorStream();
326 errorThread = new StreamCopyThread(rpErr, msg.getRawStream());
327 errorThread.start();
328
329 init(process.getInputStream(), process.getOutputStream());
330
331 } catch (TransportException err) {
332 close();
333 throw err;
334 } catch (IOException err) {
335 close();
336 throw new TransportException(uri,
337 JGitText.get().remoteHungUpUnexpectedly, err);
338 }
339
340 try {
341 readAdvertisedRefs();
342 } catch (NoRemoteRepositoryException notFound) {
343 final String msgs = getMessages();
344 checkExecFailure(process.exitValue(), getOptionReceivePack(),
345 msgs);
346 throw cleanNotFound(notFound, msgs);
347 }
348 }
349
350 @Override
351 public void close() {
352 endOut();
353
354 if (errorThread != null) {
355 try {
356 errorThread.halt();
357 } catch (InterruptedException e) {
358
359 } finally {
360 errorThread = null;
361 }
362 }
363
364 super.close();
365 if (process != null)
366 process.destroy();
367 }
368 }
369 }