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