webinterface.git

1) <?php

2) /*
3) This file belongs to the Webinterface of schokokeks.org Hosting
4) 

5) Written by schokokeks.org Hosting, namely

6)   Bernd Wurst <bernd@schokokeks.org>
7)   Hanno Böck <hanno@schokokeks.org>
8) 

9) This code is published under a 0BSD license.

10) 
11) Nevertheless, in case you use a significant part of this code, we ask (but not require, see the license) that you keep the authors' names in place and return your changes to the public. We would be especially happy if you tell us what you're going to do with this code.
12) */
13) 

14) require_role(ROLE_SYSTEMUSER);
15) 

16) $data_dir = realpath(dirname(__FILE__).'/../../../../gitolite-data/');

17) $config_file = $data_dir.'/gitolite-admin/conf/webinterface.conf';
18) $config_dir = $data_dir.'/gitolite-admin/conf/webinterface';
19) $key_dir = $data_dir.'/gitolite-admin/keydir';
20) DEBUG("gitolite-data_dir: ".$data_dir);

21) $git_wrapper = realpath(dirname(__FILE__).'/../scripts/git-wrapper.sh');

22) 
23) 

24) 

25) function check_env()

26) {

27)     global $git_wrapper, $data_dir, $config_file, $config_dir, $key_dir;
28)     if (!is_executable($git_wrapper)) {
29)         system_failure("git_wrapper.sh is not executable: {$git_wrapper}");
30)     }

31)     if (!(is_file($data_dir.'/sshkey') && is_file($data_dir.'/sshkey.pub'))) {

32)         system_failure("SSH-key not found. Please setup the gitolite-module correctly. Run ./data/initialize.sh");
33)     }

34)     if (!is_dir($data_dir.'/gitolite-admin')) {

35)         system_failure("Repository gitolite-admin ot found. Initial checkout must be made manually. Run ./data/initialize.sh");
36)     }

37)     if (!is_dir($config_dir)) {

38)         system_failure("gitolite-admin repository is not prepared.");
39)     }

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

41)         system_failure("Repository gitolite-admin is corrupted or webinterface.conf is not writeable.");
42)     }

43) }
44) 
45) 

46) function validate_name($name)
47) {
48)     return (preg_match('/^[[:alnum:]][[:alnum:]._-]*$/', $name));

49) }
50) 

51) function get_git_url($repo)
52) {
53)     $remote = git_wrapper('remote --verbose');
54)     DEBUG('gitolite-admin repo: '.$remote[0]);
55)     $url = preg_replace('#^.*\s+(\S+):gitolite-admin.*#', '$1', $remote[0]);
56)     DEBUG('URL: '.$url);
57)     return $url.':'.$repo;

58) }
59) 

60) 

61) function git_wrapper($commandline)
62) {

63)     global $git_wrapper, $data_dir;
64) 
65)     $command = $git_wrapper.' '.$commandline;

66)     $output = [];

67)     $retval = 0;
68)     DEBUG($command);
69)     exec($command, $output, $retval);
70)     DEBUG($output);
71)     DEBUG($retval);
72)     if ($retval > 0) {
73)         system_failure('Interner Fehler!');
74)         // FIXME: Hier sollte auf jeden Fall ein Logging angeworfen werden!
75)     }
76)     return $output;

77) }
78) 

79) function refresh_gitolite()

80) {

81)     check_env();
82)     git_wrapper('pull');

83) }
84) 
85) 
86) 

87) function list_repos()

88) {

89)     global $config_file, $config_dir;
90)     $username = $_SESSION['userinfo']['username'];
91)     $userconfig = $config_dir . '/' . $username . '.conf';
92)     DEBUG("using config file ".$userconfig);

93)     if (!is_file($userconfig)) {

94)         DEBUG("user-config does not exist");

95)         return [];

96)     }
97) 

98)     $repos = [];

99)     $lines = file($userconfig);
100)     $current_repo = null;

101)     $current_repo_users = [];

102)     foreach ($lines as $line) {
103)         DEBUG("LINE: ".$line);

104)         $m = [];

105)         if (preg_match('/^(\S+) "[^"]+" = "([^"]+)"$/', $line, $m) != 0) {
106)             if (!array_key_exists($m[1], $repos)) {

107)                 $repos[$m[1]] = ['users' => null, 'description' => ''];

108)             }
109)             DEBUG("found description: {$m[1]} = \"{$m[2]}\"");
110)             $repos[$m[1]]['description'] = $m[2];
111)         } elseif (preg_match('_^\s*repo (\S+)\s*$_', $line, $m) != 0) {
112)             if (!array_key_exists($m[1], $repos)) {

113)                 $repos[$m[1]] = ['users' => null, 'description' => ''];

114)             }
115)             if ($current_repo) {
116)                 $repos[$current_repo]['users'] = $current_repo_users;
117)             }
118)             DEBUG("found repo ".$m[1]);
119)             $current_repo = chop($m[1]);

120)             verify_input_identifier($current_repo);

121)             $current_repo_users = [];

122)         } elseif (preg_match('/^\s*(R|RW|RW\+)\s*=\s*([[:alnum:]][[:alnum:]._-]*)\s*$/', $line, $m) != 0) {
123)             DEBUG("found access rule: ".$m[1]." for ".$m[2]);
124)             $current_repo_users[chop($m[2])] = chop($m[1]);
125)         }
126)     }
127)     if ($current_repo) {

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

129)     }
130)     ksort($repos);
131)     DEBUG($repos);
132)     return $repos;

133) }
134) 
135) 

136) function list_users()
137) {
138)     global $config_file, $config_dir;
139)     $username = $_SESSION['userinfo']['username'];
140)     $userconfig = $config_dir . '/' . $username . '.conf';
141)     DEBUG("using config file ".$userconfig);

142)     if (!is_file($userconfig)) {

143)         DEBUG("user-config does not exist");

144)         return [];

145)     }

146) 

147)     $lines = file($userconfig);

148)     $users = [];

149)     foreach ($lines as $line) {

150)         $m = [];

151)         if (preg_match('_# user ([^]]+)_', $line, $m) != 0) {

152)             $currentuser = trim($m[1]);
153)             verify_input_identifier($currentuser);
154)             $users[] = $currentuser;

155)         }
156)         if (preg_match('_^\s*repo .*_', $line) != 0) {
157)             break;
158)         }
159)     }
160)     sort($users);
161)     DEBUG($users);
162)     return $users;

163) }

164) 

165) function list_foreign_users()
166) {
167)     global $config_file, $config_dir;
168)     $username = $_SESSION['userinfo']['username'];
169)     $userconfig = $config_dir . '/' . $username . '.conf';
170)     DEBUG("using config file ".$userconfig);

171)     if (!is_file($userconfig)) {

172)         DEBUG("user-config does not exist");

173)         return [];

174)     }

175) 

176)     $lines = file($userconfig);

177)     $users = [];

178)     foreach ($lines as $line) {

179)         $m = [];

180)         if (preg_match('_# foreign user ([^]]+)_', $line, $m) != 0) {
181)             $users[] = chop($m[1]);
182)         }
183)         if (preg_match('_^\s*repo .*_', $line) != 0) {
184)             break;
185)         }
186)     }
187)     sort($users);
188)     DEBUG($users);
189)     return $users;

190) }
191) 

192) function get_pubkey($handle)
193) {
194)     global $key_dir;

195)     if (!validate_name($handle)) {

196)         return '';
197)     }
198)     $keyfile = $key_dir.'/'.$handle.'.pub';

199)     if (!file_exists($keyfile)) {

200)         return '';
201)     }
202)     return file_get_contents($keyfile);

203) }
204) 
205) 
206) 

207) function new_foreign_user($handle)

208) {

209)     global $key_dir, $config_dir;
210)     $username = $_SESSION['userinfo']['username'];
211) 

212)     if (!validate_name($handle)) {

213)         system_failure("Der eingegebene Name enthält ungültige Zeichen. Bitte nur Buchstaben, Zahlen, Unterstrich, Binderstrich und Punkt benutzen.");
214)     }
215) 
216)     if (in_array($handle, list_users())) {
217)         system_failure('Dieser GIT-Benutzer gehört zu diesem Kundenaccount.');
218)     }
219) 
220)     $keyfile = $key_dir.'/'.$handle.'.pub';

221)     if (!file_exists($keyfile)) {

222)         system_failure('Diesen GIT-Benutzer gibt es nicht');
223)     }
224) 
225)     $userconfig = $config_dir . '/' . $username . '.conf';
226)     DEBUG("using config file ".$userconfig);

227)     if (!is_file($userconfig)) {

228)         DEBUG("user-config does not exist, creating new one");

229)         file_put_contents($userconfig, '# foreign user '.$handle."\n");

230)         set_user_include();
231)     } elseif (in_array($handle, list_foreign_users())) {
232)         # user ist schon eingetragen
233)     } else {
234)         $content = file_get_contents($userconfig);
235)         file_put_contents($userconfig, "# foreign user {$handle}\n".$content);
236)     }
237)     git_wrapper('add '.$userconfig);
238) 

239)     git_wrapper('commit --allow-empty -m "added new foreign user for '.$handle.'"');

240)     git_wrapper('push');

241) }
242) 
243) function delete_foreign_user($handle)
244) {

245)     global $config_dir;
246)     $username = $_SESSION['userinfo']['username'];
247) 
248)     $userconfig = $config_dir . '/' . $username . '.conf';
249)     DEBUG("using config file ".$userconfig);

250)     if (!is_file($userconfig)) {

251)         DEBUG("user-config does not exist, wtf?");
252)         system_failure("Es gibt für diesen Benutzer noch keine Konfiguration. Das sollte nicht sein!");
253)     } else {
254)         $content = file($userconfig);
255)         DEBUG("Old file:");
256)         DEBUG($content);

257)         $newcontent = [];

258)         foreach ($content as $line) {
259)             if (preg_match('/^# foreign user '.$handle.'$/', $line)) {
260)                 DEBUG("delete1: ".$line);
261)                 continue;
262)             }
263)             if (preg_match('/^\s*(R|RW|RW+)\s*=\s*'.$handle.'\s*$/', $line)) {
264)                 DEBUG("delete2: ".$line);
265)                 continue;
266)             }
267)             $newcontent[] = $line;
268)         }
269)         DEBUG("Modified file:");
270)         DEBUG($newcontent);
271)         file_put_contents($userconfig, implode('', $newcontent));
272)     }
273)     git_wrapper('add '.$userconfig);
274) 
275)     git_wrapper('commit -m "deleted foreign user '.$handle.' for '.$username.'"');
276)     git_wrapper('push');

277) }
278) 
279) 

280) function newkey($pubkey, $handle)

281) {

282)     global $key_dir, $config_dir;
283)     $username = $_SESSION['userinfo']['username'];

284) 

285)     $handle = $username.'-'.$handle;

286)     if (!validate_name($handle) || (str_replace(".", "x", $handle) != $handle)) {

287)         system_failure("Der eingegebene Name enthält ungültige Zeichen. Bitte nur Buchstaben, Zahlen, Unterstrich und Bindestrich benutzen.");
288)     }

289) 

290)     $pubkey = trim(str_replace(["\r", "\n"], ' ', $pubkey));

291) 

292)     $keyfile = $key_dir.'/'.$handle.'.pub';
293)     file_put_contents($keyfile, $pubkey);

294) 

295)     DEBUG("checking public key $keyfile");
296)     $proc = popen("/usr/bin/ssh-keygen -l -f '{$keyfile}' 2>&1", 'r');
297)     $output = fread($proc, 512);
298)     DEBUG($output);
299)     pclose($proc);
300)     if (preg_match('/.* is not a public key file.*/', $output)) {
301)         unlink($keyfile);
302)         system_failure('Der angegebene SSH-Key scheint ungültig zu sein.');
303)     }

304) 

305) 

306)     git_wrapper('add '.$keyfile);
307) 
308)     $userconfig = $config_dir . '/' . $username . '.conf';
309)     DEBUG("using config file ".$userconfig);

310)     if (!is_file($userconfig)) {

311)         DEBUG("user-config does not exist, creating new one");
312)         file_put_contents($userconfig, '# user '.$handle."\n");
313)         set_user_include();
314)     } elseif (in_array($handle, list_users())) {
315)         # user ist schon eingetragen, nur neuer Key
316)     } else {
317)         $content = file_get_contents($userconfig);
318)         file_put_contents($userconfig, "# user {$handle}\n".$content);
319)     }
320)     git_wrapper('add '.$userconfig);

321) 

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

324) }
325) 
326) 

327) function delete_key($handle)
328) {

329)     global $key_dir, $config_dir;
330)     $username = $_SESSION['userinfo']['username'];

331) 

332)     if (!validate_name($handle)) {

333)         system_failure("Der eingegebene Name enthält ungültige Zeichen. Bitte nur Buchstaben, Zahlen, Unterstrich, Binderstrich und Punkt benutzen.");
334)     }
335)     if (!in_array($handle, list_users())) {
336)         DEBUG("key {$handle} not in");
337)         DEBUG(list_users());
338)         system_failure("Den angegebenen Key scheint es nicht zu geben");
339)     }

340) 

341)     $keyfile = $key_dir.'/'.$handle.'.pub';

342)     if (!file_exists($keyfile)) {

343)         system_failure("Der angegebene Schlüssel scheint nicht mehr vorhanden zu sein. Bitte manuelle Korrektur anfordern!");
344)     }
345)     git_wrapper('rm '.$keyfile);
346) 
347) 
348)     $userconfig = $config_dir . '/' . $username . '.conf';
349)     DEBUG("using config file ".$userconfig);

350)     if (!is_file($userconfig)) {

351)         DEBUG("user-config does not exist, wtf?");
352)         system_failure("Es gibt für diesen Benutzer noch keine Konfiguration. Das sollte nicht sein!");
353)     } else {
354)         $content = file($userconfig);
355)         DEBUG("Old file:");
356)         DEBUG($content);

357)         $newcontent = [];

358)         foreach ($content as $line) {
359)             if (preg_match('/^# user '.$handle.'$/', $line)) {
360)                 DEBUG("delete1: ".$line);
361)                 continue;
362)             }
363)             if (preg_match('/^\s*(R|RW|RW+)\s*=\s*'.$handle.'\s*$/', $line)) {
364)                 DEBUG("delete2: ".$line);
365)                 continue;
366)             }
367)             $newcontent[] = $line;
368)         }
369)         DEBUG("Modified file:");
370)         DEBUG($newcontent);
371)         file_put_contents($userconfig, implode('', $newcontent));
372)     }
373)     git_wrapper('add '.$userconfig);

374) 

375)     git_wrapper('commit -m "deleted key for '.$handle.'"');
376)     git_wrapper('push');

377) }

378) 
379) 

380) function remove_repo_from_array($data, $repo)
381) {
382)     DEBUG("Request to remove repo »{$repo}«...");
383)     $inside = false;

384)     $outdata = [];

385)     $blank = true;
386)     foreach ($data as $line) {
387)         if ($blank && chop($line) == '') {
388)             continue;
389)         }
390)         $blank = (chop($line) == '');

391)         $m = [];

392)         if (preg_match('_^\s*repo (\S+)\s*$_', $line, $m) != 0) {
393)             $inside = ($m[1] == $repo);
394)         }

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

396)             $outdata[] = $line;
397)         }

398)     }

399)     DEBUG($outdata);
400)     return $outdata;

401) }
402) 
403) 

404) function repo_exists_globally($repo)

405) {

406)     global $config_dir;
407)     $files = scandir($config_dir);
408)     foreach ($files as $f) {
409)         if (is_file(realpath($config_dir.'/'.$f))) {
410)             $data = file(realpath($config_dir.'/'.$f));
411)             foreach ($data as $line) {
412)                 if (preg_match('/^\s*repo '.$repo.'\s*$/', $line) != 0) {
413)                     return true;
414)                 }
415)             }

416)         }
417)     }

418)     return false;

419) }
420) 
421) 

422) function delete_repo($repo)

423) {

424)     $repos = list_repos();
425)     if (!array_key_exists($repo, $repos)) {
426)         system_failure("Ein solches Repository existiert nicht!");
427)     }

428) 

429)     global $config_dir;
430)     $username = $_SESSION['userinfo']['username'];
431)     $userconfig = $config_dir . '/' . $username . '.conf';
432)     DEBUG("using config file ".$userconfig);
433)     $data = file($userconfig);
434)     $data = remove_repo_from_array($data, $repo);
435)     file_put_contents($userconfig, implode('', $data));
436)     git_wrapper('add '.$userconfig);

437) 

438)     git_wrapper('commit --allow-empty -m "deleted repo '.$repo.'"');
439)     git_wrapper('push');

440) }
441) 

442) 
443) function set_user_include()
444) {

445)     global $config_file, $config_dir;

446)     $username = $_SESSION['userinfo']['username'];

447)     $userconfig = $config_dir . '/' . $username . '.conf';

448)     if (!file_exists($userconfig)) {
449)         // Erzeuge eine leere Konfiguration damit das Include auf jeden Fall funktionieren kann
450)         file_put_contents($userconfig, '');
451)         git_wrapper('add '.$userconfig);
452)     }
453)     $found = false;
454)     $data = file($config_file);
455)     foreach ($data as $line) {
456)         if (preg_match('#webinterface/'.$username.'\.conf#', $line)) {
457)             $found = true;
458)         }
459)     }
460)     if (!$found) {
461)         $includeline = 'include  "webinterface/'.$username.'.conf"';
462)         $data = chop(file_get_contents($config_file));
463)         $data = $data."\n".$includeline."\n";
464)         file_put_contents($config_file, $data);
465)         git_wrapper('add '.$config_file);
466)     }

467) }
468) 
469) 

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

471) {

472)     if (!validate_name($repo)) {

473)         system_failure("Der gewählte Name entspricht nicht den Konventionen!");

474)     }
475)     if (!array_key_exists($repo, list_repos()) && repo_exists_globally($repo)) {
476)         system_failure("Der gewählte Name existiert bereits auf diesem Server. Bitte wählen Sie einen spezifischeren Namen.");
477)     }
478)     global $config_dir;
479)     $username = $_SESSION['userinfo']['username'];
480)     $userconfig = $config_dir . '/' . $username . '.conf';
481)     DEBUG("using config file ".$userconfig);

482)     $data = [];

483)     if (!is_file($userconfig)) {

484)         DEBUG("user-config does not exist, creating new one");
485)         set_user_include();
486)     } else {
487)         $data = file($userconfig);
488)     }

489) 

490)     $repos = list_repos();
491)     if (array_key_exists($repo, $repos)) {
492)         $data = remove_repo_from_array($data, $repo);
493)     }
494) 
495)     $data[] = "\n";
496)     if ($description) {
497)         $description = preg_replace('/\[\'"\r\n/', '', $description);
498)         $realname = $_SESSION['userinfo']['name'];
499)         $data[] = "{$repo} \"{$realname}\" = \"{$description}\"\n";
500)     }
501)     $data[] = 'repo '.$repo."\n";
502)     foreach ($permissions as $user => $perm) {
503)         $data[] = '  '.$perm.' = '.$user."\n";
504)     }
505)     file_put_contents($userconfig, implode('', $data));
506)     git_wrapper('add '.$userconfig);

507) 

508)     git_wrapper('commit --allow-empty -m "written repo '.$repo.'"');
509)     git_wrapper('push');