Bug 7740: Increment version number
[koha.git] / installer / InstallAuth.pm
1 # -*- tab-width: 8 -*-
2 # NOTE: This file uses 8-character tabs; do not change the tab size!
3
4 package InstallAuth;
5
6 # Copyright 2000-2002 Katipo Communications
7 #
8 # This file is part of Koha.
9 #
10 # Koha is free software; you can redistribute it and/or modify it under the
11 # terms of the GNU General Public License as published by the Free Software
12 # Foundation; either version 2 of the License, or (at your option) any later
13 # version.
14 #
15 # Koha is distributed in the hope that it will be useful, but WITHOUT ANY
16 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 # A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
18 #
19 # You should have received a copy of the GNU General Public License along
20 # with Koha; if not, write to the Free Software Foundation, Inc.,
21 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22
23 use strict;
24 #use warnings; FIXME - Bug 2505
25 use Digest::MD5 qw(md5_base64);
26
27 require Exporter;
28 use C4::Context;
29 use C4::Output;
30 use C4::Templates;
31 use C4::Koha;
32 use CGI::Session;
33
34 use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
35
36 # set the version for version checking
37 $VERSION = 3.00;
38
39 =head1 NAME
40
41 InstallAuth - Authenticates Koha users for Install process
42
43 =head1 SYNOPSIS
44
45   use CGI;
46   use InstallAuth;
47   use C4::Output;
48
49   my $query = new CGI;
50
51   my ($template, $borrowernumber, $cookie) 
52     = get_template_and_user({template_name   => "opac-main.tmpl",
53                              query           => $query,
54                              type            => "opac",
55                              authnotrequired => 1,
56                              flagsrequired   => {borrow => 1},
57                           });
58
59   output_html_with_http_headers $query, $cookie, $template->output;
60
61 =head1 DESCRIPTION
62
63     The main function of this module is to provide
64     authentification. However the get_template_and_user function has
65     been provided so that a users login information is passed along
66     automatically. This gets loaded into the template.
67     This package is different from C4::Auth in so far as 
68     C4::Auth uses many preferences which are supposed NOT to be obtainable when installing the database.
69     
70     As in C4::Auth, Authentication is based on cookies.
71
72 =head1 FUNCTIONS
73
74 =over 2
75
76 =cut
77
78 @ISA    = qw(Exporter);
79 @EXPORT = qw(
80   &checkauth
81   &get_template_and_user
82 );
83
84 =item get_template_and_user
85
86   my ($template, $borrowernumber, $cookie)
87     = get_template_and_user({template_name   => "opac-main.tmpl",
88                              query           => $query,
89                              type            => "opac",
90                              authnotrequired => 1,
91                              flagsrequired   => {borrow => 1},
92                           });
93
94     This call passes the C<query>, C<flagsrequired> and C<authnotrequired>
95     to C<&checkauth> (in this module) to perform authentification.
96     See C<&checkauth> for an explanation of these parameters.
97
98     The C<template_name> is then used to find the correct template for
99     the page. The authenticated users details are loaded onto the
100     template in the HTML::Template LOOP variable C<USER_INFO>. Also the
101     C<sessionID> is passed to the template. This can be used in templates
102     if cookies are disabled. It needs to be put as and input to every
103     authenticated page.
104
105     More information on the C<gettemplate> sub can be found in the
106     Templates.pm module.
107
108 =cut
109
110 sub get_template_and_user {
111     my $in       = shift;
112     my $query    = $in->{'query'};
113     my $language =_get_template_language($query->cookie('KohaOpacLanguage'));
114     my $path     = C4::Context->config('intrahtdocs'). "/prog/". $language;
115
116     my $tmplbase = $in->{template_name};
117     $tmplbase=~ s/\.tmpl$/.tt/;
118     my $filename = "$path/modules/" . $tmplbase;
119     my $interface = 'intranet';
120     my $template = C4::Templates->new( $interface, $filename, $tmplbase, $query);
121     
122     my ( $user, $cookie, $sessionID, $flags ) = checkauth(
123         $in->{'query'},
124         $in->{'authnotrequired'},
125         $in->{'flagsrequired'},
126         $in->{'type'}
127     );
128
129     #     use Data::Dumper;warn "utilisateur $user cookie : ".Dumper($cookie);
130
131     my $borrowernumber;
132     if ($user) {
133         $template->param( loggedinusername => $user );
134         $template->param( sessionID        => $sessionID );
135
136         # We are going to use the $flags returned by checkauth
137         # to create the template's parameters that will indicate
138         # which menus the user can access.
139         if ( ( $flags && $flags->{superlibrarian} == 1 ) ) {
140             $template->param( CAN_user_circulate        => 1 );
141             $template->param( CAN_user_catalogue        => 1 );
142             $template->param( CAN_user_parameters       => 1 );
143             $template->param( CAN_user_borrowers        => 1 );
144             $template->param( CAN_user_permission       => 1 );
145             $template->param( CAN_user_reserveforothers => 1 );
146             $template->param( CAN_user_borrow           => 1 );
147             $template->param( CAN_user_editcatalogue    => 1 );
148             $template->param( CAN_user_updatecharges    => 1 );
149             $template->param( CAN_user_acquisition      => 1 );
150             $template->param( CAN_user_management       => 1 );
151             $template->param( CAN_user_tools            => 1 );
152             $template->param( CAN_user_editauthorities  => 1 );
153             $template->param( CAN_user_serials          => 1 );
154             $template->param( CAN_user_reports          => 1 );
155         }
156     }
157     return ( $template, $borrowernumber, $cookie );
158 }
159
160 sub _get_template_language {
161
162     #verify if opac language exists in staff (bug 5660)
163     #conditions are 1) dir exists and 2) enabled in prefs
164     my ($opaclang) = @_;
165     return 'en' unless $opaclang;
166     $opaclang =~ s/[^a-zA-Z_-]*//g;
167     my $path = C4::Context->config('intrahtdocs') . "/prog/$opaclang";
168     -d $path ? $opaclang : 'en';
169 }
170
171 =item checkauth
172
173   ($userid, $cookie, $sessionID) = &checkauth($query, $noauth, $flagsrequired, $type);
174
175 Verifies that the user is authorized to run this script.  If
176 the user is authorized, a (userid, cookie, session-id, flags)
177 quadruple is returned.  If the user is not authorized but does
178 not have the required privilege (see $flagsrequired below), it
179 displays an error page and exits.  Otherwise, it displays the
180 login page and exits.
181
182 Note that C<&checkauth> will return if and only if the user
183 is authorized, so it should be called early on, before any
184 unfinished operations (e.g., if you've opened a file, then
185 C<&checkauth> won't close it for you).
186
187 C<$query> is the CGI object for the script calling C<&checkauth>.
188
189 The C<$noauth> argument is optional. If it is set, then no
190 authorization is required for the script.
191
192 C<&checkauth> fetches user and session information from C<$query> and
193 ensures that the user is authorized to run scripts that require
194 authorization.
195
196 The C<$flagsrequired> argument specifies the required privileges
197 the user must have if the username and password are correct.
198 It should be specified as a reference-to-hash; keys in the hash
199 should be the "flags" for the user, as specified in the Members
200 intranet module. Any key specified must correspond to a "flag"
201 in the userflags table. E.g., { circulate => 1 } would specify
202 that the user must have the "circulate" privilege in order to
203 proceed. To make sure that access control is correct, the
204 C<$flagsrequired> parameter must be specified correctly.
205
206 The C<$type> argument specifies whether the template should be
207 retrieved from the opac or intranet directory tree.  "opac" is
208 assumed if it is not specified; however, if C<$type> is specified,
209 "intranet" is assumed if it is not "opac".
210
211 If C<$query> does not have a valid session ID associated with it
212 (i.e., the user has not logged in) or if the session has expired,
213 C<&checkauth> presents the user with a login page (from the point of
214 view of the original script, C<&checkauth> does not return). Once the
215 user has authenticated, C<&checkauth> restarts the original script
216 (this time, C<&checkauth> returns).
217
218 The login page is provided using a HTML::Template, which is set in the
219 systempreferences table or at the top of this file. The variable C<$type>
220 selects which template to use, either the opac or the intranet 
221 authentification template.
222
223 C<&checkauth> returns a user ID, a cookie, and a session ID. The
224 cookie should be sent back to the browser; it verifies that the user
225 has authenticated.
226
227 =cut
228
229 sub checkauth {
230     my $query = shift;
231
232 # $authnotrequired will be set for scripts which will run without authentication
233     my $authnotrequired = shift;
234     my $flagsrequired   = shift;
235     my $type            = shift;
236     $type = 'intranet' unless $type;
237
238     my $dbh = C4::Context->dbh();
239     my $template_name;
240     $template_name = "installer/auth.tmpl";
241
242     # state variables
243     my $loggedin = 0;
244     my %info;
245     my ( $userid, $cookie, $sessionID, $flags, $envcookie );
246     my $logout = $query->param('logout.x');
247     if ( $sessionID = $query->cookie("CGISESSID") ) {
248         C4::Context->_new_userenv($sessionID);
249         my $session =
250           new CGI::Session( "driver:File;serializer:yaml", $sessionID,
251             { Directory => '/tmp' } );
252         if ( $session->param('cardnumber') ) {
253             C4::Context::set_userenv(
254                 $session->param('number'),
255                 $session->param('id'),
256                 $session->param('cardnumber'),
257                 $session->param('firstname'),
258                 $session->param('surname'),
259                 $session->param('branch'),
260                 $session->param('branchname'),
261                 $session->param('flags'),
262                 $session->param('emailaddress'),
263                 $session->param('branchprinter')
264             );
265             $cookie = $query->cookie(
266                 -name     => 'CGISESSID',
267                 -value    => $session->id,
268                 -HttpOnly => 1,
269             );
270             $loggedin = 1;
271             $userid   = $session->param('cardnumber');
272         }
273         my ( $ip, $lasttime );
274
275         if ($logout) {
276
277             # voluntary logout the user
278             C4::Context->_unset_userenv($sessionID);
279             $sessionID = undef;
280             $userid    = undef;
281            # Commented out due to its lack of usefulness
282            # open L, ">>/tmp/sessionlog";
283            # my $time = localtime( time() );
284            # printf L "%20s from %16s logged out at %30s (manually).\n", $userid,
285            #   $ip, $time;
286            # close L;
287         }
288     }
289     unless ($userid) {
290         my $session =
291           new CGI::Session( "driver:File;serializer:yaml", undef, { Directory => '/tmp' } );
292         $sessionID = $session->id;
293         $userid    = $query->param('userid');
294         C4::Context->_new_userenv($sessionID);
295         my $password = $query->param('password');
296         C4::Context->_new_userenv($sessionID);
297         my ( $return, $cardnumber ) = checkpw( $userid, $password );
298         if ($return) {
299             $loggedin = 1;
300             # open L, ">>/tmp/sessionlog";
301             # my $time = localtime( time() );
302             # printf L "%20s from %16s logged in  at %30s.\n", $userid,
303             #  $ENV{'REMOTE_ADDR'}, $time;
304             # close L;
305             $cookie = $query->cookie(
306                 -name     => 'CGISESSID',
307                 -value    => $sessionID,
308                 -HttpOnly => 1,
309             );
310             if ( $return == 2 ) {
311
312            #Only superlibrarian should have access to this page.
313            #Since if it is a user, it is supposed that there is a borrower table
314            #And thus that data structure is loaded.
315                 my $hash = C4::Context::set_userenv(
316                     0,                           0,
317                     C4::Context->config('user'), C4::Context->config('user'),
318                     C4::Context->config('user'), "",
319                     "NO_LIBRARY_SET",            1,
320                     ""
321                 );
322                 $session->param( 'number',     0 );
323                 $session->param( 'id',         C4::Context->config('user') );
324                 $session->param( 'cardnumber', C4::Context->config('user') );
325                 $session->param( 'firstname',  C4::Context->config('user') );
326                 $session->param( 'surname',    C4::Context->config('user'), );
327                 $session->param( 'branch',     'NO_LIBRARY_SET' );
328                 $session->param( 'branchname', 'NO_LIBRARY_SET' );
329                 $session->param( 'flags',      1 );
330                 $session->param( 'emailaddress',
331                     C4::Context->preference('KohaAdminEmailAddress') );
332                 $session->param( 'ip',       $session->remote_addr() );
333                 $session->param( 'lasttime', time() );
334                 $userid = C4::Context->config('user');
335             }
336         }
337         else {
338             if ($userid) {
339                 $info{'invalid_username_or_password'} = 1;
340                 C4::Context->_unset_userenv($sessionID);
341             }
342         }
343     }
344
345     # finished authentification, now respond
346     if ($loggedin) {
347
348         # successful login
349         unless ($cookie) {
350             $cookie = $query->cookie(
351                 -name    => 'CGISESSID',
352                 -value   => '',
353                 -HttpOnly => 1,
354                 -expires => ''
355             );
356         }
357         if ($envcookie) {
358             return ( $userid, [ $cookie, $envcookie ], $sessionID, $flags );
359         }
360         else {
361             return ( $userid, $cookie, $sessionID, $flags );
362         }
363     }
364
365     # else we have a problem...
366     # get the inputs from the incoming query
367     my @inputs = ();
368     foreach my $name ( param $query) {
369         (next) if ( $name eq 'userid' || $name eq 'password' );
370         my $value = $query->param($name);
371         push @inputs, { name => $name, value => $value };
372     }
373
374     my $path =
375       C4::Context->config('intrahtdocs') . "/prog/"
376       . ( $query->param('language') ? $query->param('language') : "en" );
377     my $filename = "$path/modules/$template_name";
378     $filename =~ s/\.tmpl$/.tt/;
379     my $interface = 'intranet';
380     my $template = C4::Templates->new( $interface, $filename, '', $query);
381     $template->param(
382         INPUTS => \@inputs,
383
384     );
385     $template->param( login => 1 );
386     $template->param( loginprompt => 1 ) unless $info{'nopermission'};
387
388     my $self_url = $query->url( -absolute => 1 );
389     $template->param( url => $self_url, );
390     $template->param( \%info );
391     $cookie = $query->cookie(
392         -name    => 'CGISESSID',
393         -value   => $sessionID,
394         -HttpOnly => 1,
395         -expires => ''
396     );
397     print $query->header(
398         -type    => 'text/html; charset=utf-8',
399         -cookie  => $cookie
400       ),
401       $template->output;
402     exit;
403 }
404
405 sub checkpw {
406
407     my ( $userid, $password ) = @_;
408
409     if (   $userid
410         && $userid     eq C4::Context->config('user')
411         && "$password" eq C4::Context->config('pass') )
412     {
413
414         # Koha superuser account
415         C4::Context->set_userenv(
416             0, 0,
417             C4::Context->config('user'),
418             C4::Context->config('user'),
419             C4::Context->config('user'),
420             "", 1
421         );
422         return 2;
423     }
424     if (   $userid
425         && $userid     eq 'demo'
426         && "$password" eq 'demo'
427         && C4::Context->config('demo') )
428     {
429
430 # DEMO => the demo user is allowed to do everything (if demo set to 1 in koha.conf
431 # some features won't be effective : modify systempref, modify MARC structure,
432         return 2;
433     }
434     return 0;
435 }
436
437 END { }    # module clean-up code here (global destructor)
438 1;
439 __END__
440
441 =back
442
443 =head1 SEE ALSO
444
445 CGI(3)
446
447 C4::Output(3)
448
449 Digest::MD5(3)
450
451 =cut