webinterface.git

1) <?php
2) require_role(ROLE_SYSTEMUSER);
3) 
4) $data_dir = realpath( dirname(__FILE__).'/../data/' );
5) $config_file = $data_dir.'/gitolite-admin/conf/webinterface.conf';
6) $config_dir = $data_dir.'/gitolite-admin/conf/webinterface';
7) $key_dir = $data_dir.'/gitolite-admin/keydir';
8) DEBUG("gitolite-data_dir: ".$data_dir);
9) $git_wrapper = $data_dir . '/git-wrapper.sh';
10) 
11) 

12) 

13) function check_env() 
14) {
15)   global $git_wrapper, $data_dir, $config_file, $config_dir, $key_dir;
16)   if (!is_executable($git_wrapper)) {
17)     system_failure("git_wrapper.sh is not executable: {$git_wrapper}");
18)   }
19)   if (! (is_file($data_dir.'/sshkey') && is_file($data_dir.'/sshkey.pub'))) {
20)     system_failure("SSH-key not found. Please setup the gitolite-module correctly. Run ./data/initialize.sh");
21)   }
22)   if (! is_dir($data_dir.'/gitolite-admin')) {
23)     system_failure("Repository gitolite-admin ot found. Initial checkout must be made manually. Run ./data/initialize.sh");
24)   }
25)   if (! is_dir($config_dir)) {
26)     system_failure("gitolite-admin repository is not prepared.");
27)   }

28)   if (! (is_dir($key_dir) && is_writeable($config_file))) {

29)     system_failure("Repository gitolite-admin is corrupted or webinterface.conf is not writeable.");
30)   }
31) }
32) 
33) 

34) function validate_name($name) {
35)   return (preg_match('/^[[:alnum:]][[:alnum:]._-]*$/', $name));
36) }
37) 

38) function get_git_url($repo) {
39)   $remote = git_wrapper('remote --verbose');
40)   DEBUG('gitolite-admin repo: '.$remote[0]);
41)   $url = preg_replace('#^.*\s+(\S+):gitolite-admin.*#', '$1', $remote[0]);
42)   DEBUG('URL: '.$url);
43)   return $url.':'.$repo;
44) }
45) 

46) 

47) function git_wrapper($commandline)
48) {
49)   global $git_wrapper, $data_dir;
50) 
51)   $command = $git_wrapper.' '.$commandline;
52)   $output = array();
53)   $retval = 0;
54)   DEBUG($command);
55)   exec($command, $output, $retval);
56)   DEBUG($output);
57)   DEBUG($retval);
58)   if ($retval > 0) {
59)     system_failure('Interner Fehler!');
60)     // FIXME: Hier sollte auf jeden Fall ein Logging angeworfen werden!
61)   }

62)   return $output;

63) }
64) 
65) function refresh_gitolite() 
66) {
67)   check_env();
68)   git_wrapper('pull');
69) }
70) 
71) 
72) 
73) function list_repos() 
74) {
75)   global $config_file, $config_dir;
76)   $username = $_SESSION['userinfo']['username'];
77)   $userconfig = $config_dir . '/' . $username . '.conf';
78)   DEBUG("using config file ".$userconfig);
79)   if (! is_file($userconfig)) {
80)     DEBUG("user-config does not exist");
81)     return array();
82)   }
83) 
84)   $repos = array();
85)   $lines = file($userconfig);
86)   $current_repo = NULL;

87)   $current_repo_users = array();

88)   foreach ($lines as $line) {

89)     DEBUG("LINE: ".$line);

90)     $m = array();

91)     if (preg_match('/^(\S+) "[^"]+" = "([^"]+)"$/', $line, $m) != 0) {
92)       if (!array_key_exists($m[1], $repos)) {
93)         $repos[$m[1]] = array('users' => NULL, 'description' => '');
94)       }
95)       DEBUG("found description: {$m[1]} = \"{$m[2]}\"");
96)       $repos[$m[1]]['description'] = $m[2];
97)     } elseif (preg_match('_^\s*repo (\S+)\s*$_', $line, $m) != 0) {
98)       if (!array_key_exists($m[1], $repos)) {
99)         $repos[$m[1]] = array('users' => NULL, 'description' => '');
100)       }

101)       if ($current_repo) {

102)         $repos[$current_repo]['users'] = $current_repo_users;

103)       }

104)       DEBUG("found repo ".$m[1]);

105)       $current_repo = chop($m[1]);
106)       $current_repo_users = array();

107)     } else if (preg_match('/^\s*(R|RW|RW\+)\s*=\s*([[:alnum:]][[:alnum:]._-]*)\s*$/', $line, $m) != 0) {

108)       DEBUG("found access rule: ".$m[1]." for ".$m[2]);
109)       $current_repo_users[chop($m[2])] = chop($m[1]);

110)     }
111)   }

112)   if ($current_repo) {

113)     $repos[$current_repo]['users'] = $current_repo_users;

114)   }

115)   ksort($repos);

116)   DEBUG($repos);
117)   return $repos;
118) }
119) 
120) 
121) 

122) function list_users() {
123)   global $config_file, $config_dir;
124)   $username = $_SESSION['userinfo']['username'];
125)   $userconfig = $config_dir . '/' . $username . '.conf';
126)   DEBUG("using config file ".$userconfig);
127)   if (! is_file($userconfig)) {
128)     DEBUG("user-config does not exist");
129)     return array();
130)   }
131)   
132)   $lines = file($userconfig);
133)   $users = array();
134)   foreach ($lines as $line) {
135)     $m = array();
136)     if (preg_match('_# user ([^]]+)_', $line, $m) != 0) {
137)       $users[] = chop($m[1]);
138)     }
139)     if (preg_match('_^\s*repo .*_', $line) != 0) {
140)       break;
141)     }
142)   }

143)   sort($users);

144)   DEBUG($users);
145)   return $users;
146) }

147) 

148) function get_pubkey($handle) {
149)   global $key_dir;
150)   if (! validate_name($handle)) {
151)     return '';
152)   }
153)   $keyfile = $key_dir.'/'.$handle.'.pub';
154)   if (! file_exists($keyfile)) {
155)     return '';
156)   }
157)   return file_get_contents($keyfile);
158) }
159) 
160) 
161) 
162) function newkey($pubkey, $handle)

163) {

164)   global $key_dir, $config_dir;
165)   $username = $_SESSION['userinfo']['username'];
166)   
167)   $handle = $username.'-'.$handle;
168)   if (! validate_name($handle)) {
169)     system_failure("Der eingegebene Name enthält ungültige Zeichen. Bitte nur Buchstaben, Zahlen, Unterstrich, Binderstrich und Punkt benutzen.");
170)   }
171) 
172)   $keyfile = $key_dir.'/'.$handle.'.pub';
173)   file_put_contents($keyfile, $pubkey);

174)   
175)   $proc = popen("/usr/bin/ssh-keygen -l -f '{$keyfile}'", 'r');
176)   $output = fread($proc, 512);
177)   pclose($proc);
178)   if (preg_match('/.* is not a public key file.*/', $output)) {
179)     unlink($keyfile);
180)     system_failure('Der angegebene SSH-Key scheint ungültig zu sein.');
181)   }
182)   
183) 

184)   git_wrapper('add '.$keyfile);
185) 
186)   $userconfig = $config_dir . '/' . $username . '.conf';
187)   DEBUG("using config file ".$userconfig);
188)   if (! is_file($userconfig)) {
189)     DEBUG("user-config does not exist, creating new one");
190)     file_put_contents($userconfig, '# user '.$handle."\n");

191)     set_user_include();

192)   } elseif (in_array($handle, list_users())) {
193)     # user ist schon eingetragen, nur neuer Key
194)   } else {
195)     $content = file_get_contents($userconfig);
196)     file_put_contents($userconfig, "# user {$handle}\n".$content);
197)   }
198)   git_wrapper('add '.$userconfig);

199)   

200)   git_wrapper('commit --allow-empty -m "added new key for '.$handle.'"');
201)   git_wrapper('push');

202) }
203) 
204) 

205) function delete_key($handle)
206) {
207)   global $key_dir, $config_dir;
208)   $username = $_SESSION['userinfo']['username'];

209) 

210)   if (! validate_name($handle)) {
211)     system_failure("Der eingegebene Name enthält ungültige Zeichen. Bitte nur Buchstaben, Zahlen, Unterstrich, Binderstrich und Punkt benutzen.");
212)   }
213)   if (!in_array($handle, list_users())) {
214)     DEBUG("key {$handle} not in");
215)     DEBUG(list_users());
216)     system_failure("Den angegebenen Key scheint es nicht zu geben");
217)   }
218) 
219)   // FIXME: Muss man den SSH-Key auf Plausibilität prüfen? Aus Sicherheitsgründen vermutlich nicht.
220)   $keyfile = $key_dir.'/'.$handle.'.pub';
221)   if (! file_exists($keyfile)) {
222)     system_failure("Der angegebene Schlüssel scheint nicht mehr vorhanden zu sein. Bitte manuelle Korrektur anfordern!");
223)   } 
224)   git_wrapper('rm '.$keyfile);
225) 
226) 
227)   $userconfig = $config_dir . '/' . $username . '.conf';
228)   DEBUG("using config file ".$userconfig);
229)   if (! is_file($userconfig)) {
230)     DEBUG("user-config does not exist, wtf?");
231)     system_failure("Es gibt für diesen Benutzer noch keine Konfiguration. Das sollte nicht sein!");
232)   } else {
233)     $content = file($userconfig);
234)     DEBUG("Old file:");
235)     DEBUG($content);
236)     $newcontent = array();
237)     foreach ($content as $line) {
238)       if (preg_match('/^# user '.$handle.'$/', $line)) {
239)         DEBUG("delete1: ".$line);
240)         continue;
241)       }
242)       if (preg_match('/^\s*(R|RW|RW+)\s*=\s*'.$handle.'\s*$/', $line)) {
243)         DEBUG("delete2: ".$line);
244)         continue;
245)       }
246)       $newcontent[] = $line;
247)     }
248)     DEBUG("Modified file:");
249)     DEBUG($newcontent);
250)     file_put_contents($userconfig, implode('', $newcontent));
251)   }
252)   git_wrapper('add '.$userconfig);
253)  
254)   git_wrapper('commit -m "deleted key for '.$handle.'"');
255)   git_wrapper('push');
256) 
257) 
258) }

259) 
260) 
261) function remove_repo_from_array($data, $repo) {
262)   DEBUG("Request to remove repo »{$repo}«...");
263)   $inside = false;
264)   $outdata = array();

265)   $blank = true;

266)   foreach ($data as $line) {

267)     if ($blank && chop($line) == '') {
268)       continue;
269)     }
270)     $blank = (chop($line) == '');

271)     $m = array();
272)     if (preg_match('_^\s*repo (\S+)\s*$_', $line, $m) != 0) {
273)       $inside = ($m[1] == $repo);
274)     }

275)     if (! $inside && ! preg_match('/^'.$repo.'\s.*/', $line)) {

276)       $outdata[] = $line;
277)     }
278)   }
279)   DEBUG($outdata);
280)   return $outdata;
281) }
282) 
283) 
284) function repo_exists_globally($repo) 
285) {
286)   global $config_dir;
287)   $files = scandir($config_dir);
288)   foreach ($files as $f) {
289)     if (is_file(realpath($config_dir.'/'.$f))) {
290)       $data = file(realpath($config_dir.'/'.$f));
291)       foreach ($data as $line) {
292)         if (preg_match('/^\s*repo '.$repo.'\s*$/', $line) != 0) {
293)           return true;
294)         }
295)       }
296)     }
297)   }
298)   return false;
299) }
300) 
301) 
302) function delete_repo($repo) 
303) {
304)   $repos = list_repos();
305)   if (!array_key_exists($repo, $repos)) {
306)     system_failure("Ein solches Repository existiert nicht!");
307)   }
308)   
309)   global $config_dir;
310)   $username = $_SESSION['userinfo']['username'];
311)   $userconfig = $config_dir . '/' . $username . '.conf';
312)   DEBUG("using config file ".$userconfig);
313)   $data = file($userconfig);
314)   $data = remove_repo_from_array($data, $repo);
315)   file_put_contents($userconfig, implode('', $data));
316)   git_wrapper('add '.$userconfig);
317)   
318)   git_wrapper('commit --allow-empty -m "deleted repo '.$repo.'"');
319)   git_wrapper('push');
320) }
321) 

322) 
323) function set_user_include()
324) {
325)   global $config_file, $userconfig;
326)   $username = $_SESSION['userinfo']['username'];
327)   if (!file_exists($userconfig))
328)   {
329)     // Erzeuge eine leere Konfiguration damit das Include auf jeden Fall funktionieren kann
330)     file_put_contents($userconfig, '');
331)     git_wrapper('add '.$userconfig);
332)   }
333)   $found = false;
334)   $data = file($config_file);
335)   foreach ($data as $line) {
336)     if (preg_match('#webinterface/'.$username.'\.conf#', $line)) {
337)       $found = true;
338)     }
339)   }
340)   if (!$found) {
341)     $includeline = 'include  "webinterface/'.$username.'.conf"';
342)     $data = chop(file_get_contents($config_file));
343)     $data = $data."\n".$includeline."\n";
344)     file_put_contents($config_file, $data);
345)     git_wrapper('add '.$config_file);
346)   }
347) }
348) 
349) 

350) function save_repo($repo, $permissions, $description) 

351) {
352)   if (!validate_name($repo)) {
353)     system_failure("Der gewählte name entspricht nicht den Konventionen!");
354)   }
355)   if (!array_key_exists($repo, list_repos()) && repo_exists_globally($repo)) {
356)     system_failure("Der gewählte Name existiert bereits auf diesem Server. Bitte wählen Sie einen spezifischeren Namen.");
357)   } 
358)   global $config_dir;
359)   $username = $_SESSION['userinfo']['username'];
360)   $userconfig = $config_dir . '/' . $username . '.conf';
361)   DEBUG("using config file ".$userconfig);
362)   $data = array();
363)   if (! is_file($userconfig)) {
364)     DEBUG("user-config does not exist, creating new one");

365)     set_user_include();

366)   } else {
367)     $data = file($userconfig);
368)   }
369) 
370)   $repos = list_repos();
371)   if (array_key_exists($repo, $repos)) {
372)     $data = remove_repo_from_array($data, $repo);
373)   }
374) 
375)   $data[] = "\n";

376)   if ($description) {

377)     $description = preg_replace('/\[\'"\r\n/', '', $description);

378)     $realname = $_SESSION['userinfo']['name'];
379)     $data[] = "{$repo} \"{$realname}\" = \"{$description}\"\n";
380)   }