2010-08-30 Alejandro G. Castro <alex@igalia.com>
[WebKit-https.git] / BugsSite / attachment.cgi
1 #!/usr/bin/env perl -wT
2 # -*- Mode: perl; indent-tabs-mode: nil -*-
3 #
4 # The contents of this file are subject to the Mozilla Public
5 # License Version 1.1 (the "License"); you may not use this file
6 # except in compliance with the License. You may obtain a copy of
7 # the License at http://www.mozilla.org/MPL/
8 #
9 # Software distributed under the License is distributed on an "AS
10 # IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
11 # implied. See the License for the specific language governing
12 # rights and limitations under the License.
13 #
14 # The Original Code is the Bugzilla Bug Tracking System.
15 #
16 # The Initial Developer of the Original Code is Netscape Communications
17 # Corporation. Portions created by Netscape are
18 # Copyright (C) 1998 Netscape Communications Corporation. All
19 # Rights Reserved.
20 #
21 # Contributor(s): Terry Weissman <terry@mozilla.org>
22 #                 Myk Melez <myk@mozilla.org>
23 #                 Daniel Raichle <draichle@gmx.net>
24 #                 Dave Miller <justdave@syndicomm.com>
25 #                 Alexander J. Vincent <ajvincent@juno.com>
26 #                 Max Kanat-Alexander <mkanat@bugzilla.org>
27 #                 Greg Hendricks <ghendricks@novell.com>
28 #                 Frédéric Buclin <LpSolit@gmail.com>
29 #                 Marc Schumann <wurblzap@gmail.com>
30 #                 Byron Jones <bugzilla@glob.com.au>
31
32 ################################################################################
33 # Script Initialization
34 ################################################################################
35
36 # Make it harder for us to do dangerous things in Perl.
37 use strict;
38
39 use lib qw(. lib);
40
41 use Bugzilla;
42 use Bugzilla::Constants;
43 use Bugzilla::Error;
44 use Bugzilla::Flag; 
45 use Bugzilla::FlagType; 
46 use Bugzilla::User;
47 use Bugzilla::Util;
48 use Bugzilla::Bug;
49 use Bugzilla::Field;
50 use Bugzilla::Attachment;
51 use Bugzilla::Attachment::PatchReader;
52 use Bugzilla::Token;
53 use Bugzilla::Keyword;
54
55 #if WEBKIT_CHANGES
56 use IPC::Open2;
57 #endif // WEBKIT_CHANGES
58
59 # For most scripts we don't make $cgi and $template global variables. But
60 # when preparing Bugzilla for mod_perl, this script used these
61 # variables in so many subroutines that it was easier to just
62 # make them globals.
63 local our $cgi = Bugzilla->cgi;
64 local our $template = Bugzilla->template;
65 local our $vars = {};
66
67 ################################################################################
68 # Main Body Execution
69 ################################################################################
70
71 # All calls to this script should contain an "action" variable whose
72 # value determines what the user wants to do.  The code below checks
73 # the value of that variable and runs the appropriate code. If none is
74 # supplied, we default to 'view'.
75
76 # Determine whether to use the action specified by the user or the default.
77 my $action = $cgi->param('action') || 'view';
78
79 # You must use the appropriate urlbase/sslbase param when doing anything
80 # but viewing an attachment.
81 if ($action ne 'view') {
82     my $urlbase = Bugzilla->params->{'urlbase'};
83     my $sslbase = Bugzilla->params->{'sslbase'};
84     my $path_regexp = $sslbase ? qr/^(\Q$urlbase\E|\Q$sslbase\E)/ : qr/^\Q$urlbase\E/;
85     if (use_attachbase() && $cgi->self_url !~ /$path_regexp/) {
86         $cgi->redirect_to_urlbase;
87     }
88     Bugzilla->login();
89 }
90
91 # Determine if PatchReader is installed
92 eval {
93     require PatchReader;
94     $vars->{'patchviewerinstalled'} = 1;
95 };
96
97 # When viewing an attachment, do not request credentials if we are on
98 # the alternate host. Let view() decide when to call Bugzilla->login.
99 if ($action eq "view")
100 {
101     view();
102 }
103 elsif ($action eq "interdiff")
104 {
105     interdiff();
106 }
107 elsif ($action eq "diff")
108 {
109     diff();
110 }
111 elsif ($action eq "viewall") 
112
113     viewall(); 
114 }
115 elsif ($action eq "enter") 
116
117     Bugzilla->login(LOGIN_REQUIRED);
118     enter(); 
119 }
120 elsif ($action eq "insert")
121 {
122     Bugzilla->login(LOGIN_REQUIRED);
123     insert();
124 }
125 elsif ($action eq "edit") 
126
127     edit(); 
128 }
129 #if WEBKIT_CHANGES
130 elsif ($action eq "review")
131 {
132     edit("review");
133 }
134 elsif ($action eq "reviewform")
135 {
136     edit("reviewform");
137 }
138 elsif ($action eq "rietveldreview")
139 {
140     edit("rietveldreview");
141 }
142 #endif // WEBKIT_CHANGES
143 elsif ($action eq "update") 
144
145     Bugzilla->login(LOGIN_REQUIRED);
146     update();
147 }
148 #if WEBKIT_CHANGES
149 elsif ($action eq "prettypatch")
150 {
151     prettyPatch();
152 }
153 #endif // WEBKIT_CHANGES
154 elsif ($action eq "delete") {
155     delete_attachment();
156 }
157 else 
158
159   ThrowCodeError("unknown_action", { action => $action });
160 }
161
162 exit;
163
164 ################################################################################
165 # Data Validation / Security Authorization
166 ################################################################################
167
168 # Validates an attachment ID. Optionally takes a parameter of a form
169 # variable name that contains the ID to be validated. If not specified,
170 # uses 'id'.
171 # If the second parameter is true, the attachment ID will be validated,
172 # however the current user's access to the attachment will not be checked.
173 # Will throw an error if 1) attachment ID is not a valid number,
174 # 2) attachment does not exist, or 3) user isn't allowed to access the
175 # attachment.
176 #
177 # Returns an attachment object.
178
179 sub validateID {
180     my($param, $dont_validate_access) = @_;
181     $param ||= 'id';
182
183     # If we're not doing interdiffs, check if id wasn't specified and
184     # prompt them with a page that allows them to choose an attachment.
185     # Happens when calling plain attachment.cgi from the urlbar directly
186     if ($param eq 'id' && !$cgi->param('id')) {
187         print $cgi->header();
188         $template->process("attachment/choose.html.tmpl", $vars) ||
189             ThrowTemplateError($template->error());
190         exit;
191     }
192     
193     my $attach_id = $cgi->param($param);
194
195     # Validate the specified attachment id. detaint kills $attach_id if
196     # non-natural, so use the original value from $cgi in our exception
197     # message here.
198     detaint_natural($attach_id)
199      || ThrowUserError("invalid_attach_id", { attach_id => $cgi->param($param) });
200   
201     # Make sure the attachment exists in the database.
202     my $attachment = Bugzilla::Attachment->get($attach_id)
203       || ThrowUserError("invalid_attach_id", { attach_id => $attach_id });
204
205     return $attachment if ($dont_validate_access || check_can_access($attachment));
206 }
207
208 # Make sure the current user has access to the specified attachment.
209 sub check_can_access {
210     my $attachment = shift;
211     my $user = Bugzilla->user;
212
213     # Make sure the user is authorized to access this attachment's bug.
214     ValidateBugID($attachment->bug_id);
215     if ($attachment->isprivate && $user->id != $attachment->attacher->id && !$user->is_insider) {
216         ThrowUserError('auth_failure', {action => 'access',
217                                         object => 'attachment'});
218     }
219     return 1;
220 }
221
222 # Determines if the attachment is public -- that is, if users who are
223 # not logged in have access to the attachment
224 sub attachmentIsPublic {
225     my $attachment = shift;
226
227     return 0 if Bugzilla->params->{'requirelogin'};
228     return 0 if $attachment->isprivate;
229
230     my $anon_user = new Bugzilla::User;
231     return $anon_user->can_see_bug($attachment->bug_id);
232 }
233
234 # Validates format of a diff/interdiff. Takes a list as an parameter, which
235 # defines the valid format values. Will throw an error if the format is not
236 # in the list. Returns either the user selected or default format.
237 sub validateFormat
238 {
239   # receives a list of legal formats; first item is a default
240   my $format = $cgi->param('format') || $_[0];
241   if ( lsearch(\@_, $format) == -1)
242   {
243      ThrowUserError("invalid_format", { format  => $format, formats => \@_ });
244   }
245
246   return $format;
247 }
248
249 # Validates context of a diff/interdiff. Will throw an error if the context
250 # is not number, "file" or "patch". Returns the validated, detainted context.
251 sub validateContext
252 {
253   my $context = $cgi->param('context') || "patch";
254   if ($context ne "file" && $context ne "patch") {
255     detaint_natural($context)
256       || ThrowUserError("invalid_context", { context => $cgi->param('context') });
257   }
258
259   return $context;
260 }
261
262 sub validateCanChangeBug
263 {
264     my ($bugid) = @_;
265     my $dbh = Bugzilla->dbh;
266     my ($productid) = $dbh->selectrow_array(
267             "SELECT product_id
268              FROM bugs 
269              WHERE bug_id = ?", undef, $bugid);
270
271     Bugzilla->user->can_edit_product($productid)
272       || ThrowUserError("illegal_attachment_edit_bug",
273                         { bug_id => $bugid });
274 }
275
276 ################################################################################
277 # Functions
278 ################################################################################
279
280 # Display an attachment.
281 sub view {
282     my $attachment;
283
284     if (use_attachbase()) {
285         $attachment = validateID(undef, 1);
286         # Replace %bugid% by the ID of the bug the attachment belongs to, if present.
287         my $attachbase = Bugzilla->params->{'attachment_base'};
288         my $bug_id = $attachment->bug_id;
289         $attachbase =~ s/%bugid%/$bug_id/;
290         my $path = 'attachment.cgi?id=' . $attachment->id;
291
292         # Make sure the attachment is served from the correct server.
293         if ($cgi->self_url !~ /^\Q$attachbase\E/) {
294             # We couldn't call Bugzilla->login earlier as we first had to make sure
295             # we were not going to request credentials on the alternate host.
296             Bugzilla->login();
297             if (attachmentIsPublic($attachment)) {
298                 # No need for a token; redirect to attachment base.
299                 print $cgi->redirect(-location => $attachbase . $path);
300                 exit;
301             } else {
302                 # Make sure the user can view the attachment.
303                 check_can_access($attachment);
304                 # Create a token and redirect.
305                 my $token = url_quote(issue_session_token($attachment->id));
306                 print $cgi->redirect(-location => $attachbase . "$path&t=$token");
307                 exit;
308             }
309         } else {
310             # No need to validate the token for public attachments. We cannot request
311             # credentials as we are on the alternate host.
312             if (!attachmentIsPublic($attachment)) {
313                 my $token = $cgi->param('t');
314                 my ($userid, undef, $token_attach_id) = Bugzilla::Token::GetTokenData($token);
315                 unless ($userid
316                         && detaint_natural($token_attach_id)
317                         && ($token_attach_id == $attachment->id))
318                 {
319                     # Not a valid token.
320                     print $cgi->redirect('-location' => correct_urlbase() . $path);
321                     exit;
322                 }
323                 # Change current user without creating cookies.
324                 Bugzilla->set_user(new Bugzilla::User($userid));
325                 # Tokens are single use only, delete it.
326                 delete_token($token);
327             }
328         }
329     } else {
330         # No alternate host is used. Request credentials if required.
331         Bugzilla->login();
332         $attachment = validateID();
333     }
334
335     # At this point, Bugzilla->login has been called if it had to.
336     my $contenttype = $attachment->contenttype;
337     my $filename = $attachment->filename;
338
339     # Bug 111522: allow overriding content-type manually in the posted form
340     # params.
341     if (defined $cgi->param('content_type'))
342     {
343         $cgi->param('contenttypemethod', 'manual');
344         $cgi->param('contenttypeentry', $cgi->param('content_type'));
345         Bugzilla::Attachment->validate_content_type(THROW_ERROR);
346         $contenttype = $cgi->param('content_type');
347     }
348
349     # Return the appropriate HTTP response headers.
350     $attachment->datasize || ThrowUserError("attachment_removed");
351
352     $filename =~ s/^.*[\/\\]//;
353     # escape quotes and backslashes in the filename, per RFCs 2045/822
354     $filename =~ s/\\/\\\\/g; # escape backslashes
355     $filename =~ s/"/\\"/g; # escape quotes
356
357     my $disposition = Bugzilla->params->{'allow_attachment_display'} ? 'inline' : 'attachment';
358
359     print $cgi->header(-type=>"$contenttype; name=\"$filename\"",
360                        -content_disposition=> "$disposition; filename=\"$filename\"",
361                        -content_length => $attachment->datasize);
362     disable_utf8();
363     print $attachment->data;
364 }
365
366 sub interdiff {
367     # Retrieve and validate parameters
368     my $old_attachment = validateID('oldid');
369     my $new_attachment = validateID('newid');
370     my $format = validateFormat('html', 'raw');
371     my $context = validateContext();
372
373     Bugzilla::Attachment::PatchReader::process_interdiff(
374         $old_attachment, $new_attachment, $format, $context);
375 }
376
377 #if WEBKIT_CHANGES
378 sub prettyPatch
379 {
380     # Retrieve and validate parameters
381     my $attachment = validateID();
382     my $format = validateFormat('html', 'raw');
383     my $context = validateContext();
384
385     # If it is not a patch, view normally.
386     if (!$attachment->ispatch) {
387       view();
388       return;
389     }
390
391     use vars qw($cgi);
392     print $cgi->header(-type => 'text/html',
393                        -expires => '+3M');
394
395     my $orig_path = $ENV{'PATH'};
396     $ENV{'PATH'} = "/opt/local/bin:" . $ENV{'PATH'};
397     open2(\*OUT, \*IN, "/usr/bin/ruby", "-I", "PrettyPatch", "PrettyPatch/prettify.rb", "--html-exceptions");
398     $ENV{'PATH'} = $orig_path;
399     print IN $attachment->data . "\n";
400     close(IN);
401     while (<OUT>) {
402         print;
403     }
404     close(OUT);
405 }
406 #endif // WEBKIT_CHANGES
407
408 sub diff {
409     # Retrieve and validate parameters
410     my $attachment = validateID();
411     my $format = validateFormat('html', 'raw');
412     my $context = validateContext();
413
414     # If it is not a patch, view normally.
415     if (!$attachment->ispatch) {
416         view();
417         return;
418     }
419
420     Bugzilla::Attachment::PatchReader::process_diff($attachment, $format, $context);
421 }
422
423 # Display all attachments for a given bug in a series of IFRAMEs within one
424 # HTML page.
425 sub viewall {
426     # Retrieve and validate parameters
427     my $bugid = $cgi->param('bugid');
428     ValidateBugID($bugid);
429     my $bug = new Bugzilla::Bug($bugid);
430
431     my $attachments = Bugzilla::Attachment->get_attachments_by_bug($bugid);
432
433     # Define the variables and functions that will be passed to the UI template.
434     $vars->{'bug'} = $bug;
435     $vars->{'attachments'} = $attachments;
436
437     print $cgi->header();
438
439     # Generate and return the UI (HTML page) from the appropriate template.
440     $template->process("attachment/show-multiple.html.tmpl", $vars)
441       || ThrowTemplateError($template->error());
442 }
443
444 # Display a form for entering a new attachment.
445 sub enter {
446   # Retrieve and validate parameters
447   my $bugid = $cgi->param('bugid');
448   ValidateBugID($bugid);
449   validateCanChangeBug($bugid);
450   my $dbh = Bugzilla->dbh;
451   my $user = Bugzilla->user;
452
453   my $bug = new Bugzilla::Bug($bugid, $user->id);
454   # Retrieve the attachments the user can edit from the database and write
455   # them into an array of hashes where each hash represents one attachment.
456   my $canEdit = "";
457   if (!$user->in_group('editbugs', $bug->product_id)) {
458       $canEdit = "AND submitter_id = " . $user->id;
459   }
460   my $attach_ids = $dbh->selectcol_arrayref("SELECT attach_id FROM attachments
461                                              WHERE bug_id = ? AND isobsolete = 0 $canEdit
462                                              ORDER BY attach_id", undef, $bugid);
463
464   # Define the variables and functions that will be passed to the UI template.
465   $vars->{'bug'} = $bug;
466   $vars->{'attachments'} = Bugzilla::Attachment->get_list($attach_ids);
467
468   my $flag_types = Bugzilla::FlagType::match({'target_type'  => 'attachment',
469                                               'product_id'   => $bug->product_id,
470                                               'component_id' => $bug->component_id});
471   $vars->{'flag_types'} = $flag_types;
472   $vars->{'any_flags_requesteeble'} = grep($_->is_requesteeble, @$flag_types);
473   $vars->{'token'} = issue_session_token('createattachment:');
474
475   print $cgi->header();
476
477   # Generate and return the UI (HTML page) from the appropriate template.
478   $template->process("attachment/create.html.tmpl", $vars)
479     || ThrowTemplateError($template->error());
480 }
481
482 # Insert a new attachment into the database.
483 sub insert {
484     my $dbh = Bugzilla->dbh;
485     my $user = Bugzilla->user;
486
487     $dbh->bz_start_transaction;
488
489     # Retrieve and validate parameters
490     my $bugid = $cgi->param('bugid');
491     ValidateBugID($bugid);
492     validateCanChangeBug($bugid);
493     my ($timestamp) = Bugzilla->dbh->selectrow_array("SELECT NOW()");
494
495     # Detect if the user already used the same form to submit an attachment
496     my $token = trim($cgi->param('token'));
497     if ($token) {
498         my ($creator_id, $date, $old_attach_id) = Bugzilla::Token::GetTokenData($token);
499         unless ($creator_id 
500             && ($creator_id == $user->id) 
501                 && ($old_attach_id =~ "^createattachment:")) 
502         {
503             # The token is invalid.
504             ThrowUserError('token_does_not_exist');
505         }
506     
507         $old_attach_id =~ s/^createattachment://;
508    
509         if ($old_attach_id) {
510             $vars->{'bugid'} = $bugid;
511             $vars->{'attachid'} = $old_attach_id;
512             print $cgi->header();
513             $template->process("attachment/cancel-create-dupe.html.tmpl",  $vars)
514                 || ThrowTemplateError($template->error());
515             exit;
516         }
517     }
518
519     my $bug = new Bugzilla::Bug($bugid);
520     my $attachment =
521         Bugzilla::Attachment->insert_attachment_for_bug(THROW_ERROR, $bug, $user,
522                                                         $timestamp, $vars);
523
524     # Insert a comment about the new attachment into the database.
525     my $comment = "Created an attachment (id=" . $attachment->id . ")\n" .
526                   $attachment->description . "\n";
527     $comment .= ("\n" . $cgi->param('comment')) if defined $cgi->param('comment');
528
529     $bug->add_comment($comment, { isprivate => $attachment->isprivate });
530
531   # Assign the bug to the user, if they are allowed to take it
532   my $owner = "";
533   if ($cgi->param('takebug') && $user->in_group('editbugs', $bug->product_id)) {
534       # When taking a bug, we have to follow the workflow.
535       my $bug_status = $cgi->param('bug_status') || '';
536       ($bug_status) = grep {$_->name eq $bug_status} @{$bug->status->can_change_to};
537
538       if ($bug_status && $bug_status->is_open
539           && ($bug_status->name ne 'UNCONFIRMED' || $bug->product_obj->votes_to_confirm))
540       {
541           $bug->set_status($bug_status->name);
542           $bug->clear_resolution();
543       }
544       # Make sure the person we are taking the bug from gets mail.
545       $owner = $bug->assigned_to->login;
546       $bug->set_assigned_to($user);
547   }
548   $bug->update($timestamp);
549
550   if ($token) {
551       trick_taint($token);
552       $dbh->do('UPDATE tokens SET eventdata = ? WHERE token = ?', undef,
553                ("createattachment:" . $attachment->id, $token));
554   }
555
556   $dbh->bz_commit_transaction;
557
558   # Define the variables and functions that will be passed to the UI template.
559   $vars->{'mailrecipients'} =  { 'changer' => $user->login,
560                                  'owner'   => $owner };
561   $vars->{'attachment'} = $attachment;
562   # We cannot reuse the $bug object as delta_ts has eventually been updated
563   # since the object was created.
564   $vars->{'bugs'} = [new Bugzilla::Bug($bugid)];
565   $vars->{'header_done'} = 1;
566   $vars->{'contenttypemethod'} = $cgi->param('contenttypemethod');
567   $vars->{'use_keywords'} = 1 if Bugzilla::Keyword::keyword_count();
568
569   print $cgi->header();
570   # Generate and return the UI (HTML page) from the appropriate template.
571   $template->process("attachment/created.html.tmpl", $vars)
572     || ThrowTemplateError($template->error());
573 }
574
575 # Displays a form for editing attachment properties.
576 # Any user is allowed to access this page, unless the attachment
577 # is private and the user does not belong to the insider group.
578 # Validations are done later when the user submits changes.
579 sub edit {
580 #if WEBKIT_CHANGES
581   my ($template_name) = @_;
582   $template_name = $template_name || "edit";
583 #endif // WEBKIT_CHANGES
584
585   my $attachment = validateID();
586   my $dbh = Bugzilla->dbh;
587
588   # Retrieve a list of attachments for this bug as well as a summary of the bug
589   # to use in a navigation bar across the top of the screen.
590   my $bugattachments =
591       Bugzilla::Attachment->get_attachments_by_bug($attachment->bug_id);
592   # We only want attachment IDs.
593   @$bugattachments = map { $_->id } @$bugattachments;
594
595   my ($bugsummary, $product_id, $component_id) =
596       $dbh->selectrow_array('SELECT short_desc, product_id, component_id
597                                FROM bugs
598                               WHERE bug_id = ?', undef, $attachment->bug_id);
599
600   # Get a list of flag types that can be set for this attachment.
601   my $flag_types = Bugzilla::FlagType::match({ 'target_type'  => 'attachment' ,
602                                                'product_id'   => $product_id ,
603                                                'component_id' => $component_id });
604   foreach my $flag_type (@$flag_types) {
605     $flag_type->{'flags'} = Bugzilla::Flag->match({ 'type_id'   => $flag_type->id,
606                                                     'attach_id' => $attachment->id });
607   }
608   $vars->{'flag_types'} = $flag_types;
609   $vars->{'any_flags_requesteeble'} = grep($_->is_requesteeble, @$flag_types);
610   $vars->{'attachment'} = $attachment;
611   $vars->{'bugsummary'} = $bugsummary; 
612   $vars->{'attachments'} = $bugattachments;
613
614 #if WEBKIT_CHANGES
615   if ($attachment->ispatch) {
616       my $quotedpatch = $attachment->data;
617       $quotedpatch =~ s/^/> /mg;
618       $vars->{'quotedpatch'} = $quotedpatch;
619   }
620 #endif // WEBKIT_CHANGES
621
622   print $cgi->header();
623
624   # Generate and return the UI (HTML page) from the appropriate template.
625   $template->process("attachment/$template_name.html.tmpl", $vars) # WEBKIT_CHANGES
626     || ThrowTemplateError($template->error());
627 }
628
629 # Updates an attachment record. Users with "editbugs" privileges, (or the
630 # original attachment's submitter) can edit the attachment's description,
631 # content type, ispatch and isobsolete flags, and statuses, and they can
632 # also submit a comment that appears in the bug.
633 # Users cannot edit the content of the attachment itself.
634 sub update {
635     my $user = Bugzilla->user;
636     my $dbh = Bugzilla->dbh;
637
638     # Retrieve and validate parameters
639     my $attachment = validateID();
640     my $bug = new Bugzilla::Bug($attachment->bug_id);
641     $attachment->validate_can_edit($bug->product_id);
642     validateCanChangeBug($bug->id);
643     Bugzilla::Attachment->validate_description(THROW_ERROR);
644     Bugzilla::Attachment->validate_is_patch(THROW_ERROR);
645     Bugzilla::Attachment->validate_content_type(THROW_ERROR) unless $cgi->param('ispatch');
646     $cgi->param('isobsolete', $cgi->param('isobsolete') ? 1 : 0);
647     $cgi->param('isprivate', $cgi->param('isprivate') ? 1 : 0);
648
649     # Now make sure the attachment has not been edited since we loaded the page.
650     if (defined $cgi->param('delta_ts')
651         && $cgi->param('delta_ts') ne $attachment->modification_time)
652     {
653         ($vars->{'operations'}) =
654             Bugzilla::Bug::GetBugActivity($bug->id, $attachment->id, $cgi->param('delta_ts'));
655
656         # The token contains the old modification_time. We need a new one.
657         $cgi->param('token', issue_hash_token([$attachment->id, $attachment->modification_time]));
658
659         # If the modification date changed but there is no entry in
660         # the activity table, this means someone commented only.
661         # In this case, there is no reason to midair.
662         if (scalar(@{$vars->{'operations'}})) {
663             $cgi->param('delta_ts', $attachment->modification_time);
664             $vars->{'attachment'} = $attachment;
665
666             print $cgi->header();
667             # Warn the user about the mid-air collision and ask them what to do.
668             $template->process("attachment/midair.html.tmpl", $vars)
669               || ThrowTemplateError($template->error());
670             exit;
671         }
672     }
673
674     # We couldn't do this check earlier as we first had to validate attachment ID
675     # and display the mid-air collision page if modification_time changed.
676     my $token = $cgi->param('token');
677     check_hash_token($token, [$attachment->id, $attachment->modification_time]);
678
679     # If the submitter of the attachment is not in the insidergroup,
680     # be sure that he cannot overwrite the private bit.
681     # This check must be done before calling Bugzilla::Flag*::validate(),
682     # because they will look at the private bit when checking permissions.
683     # XXX - This is a ugly hack. Ideally, we shouldn't have to look at the
684     # old private bit twice (first here, and then below again), but this is
685     # the less risky change.
686     unless ($user->is_insider) {
687         $cgi->param('isprivate', $attachment->isprivate);
688     }
689
690     # If the user submitted a comment while editing the attachment,
691     # add the comment to the bug. Do this after having validated isprivate!
692     if ($cgi->param('comment')) {
693         # Prepend a string to the comment to let users know that the comment came
694         # from the "edit attachment" screen.
695         my $comment = "(From update of attachment " . $attachment->id . ")\n" .
696                       $cgi->param('comment');
697
698         $bug->add_comment($comment, { isprivate => $cgi->param('isprivate') });
699     }
700
701     # The order of these function calls is important, as Flag::validate
702     # assumes User::match_field has ensured that the values in the
703     # requestee fields are legitimate user email addresses.
704     Bugzilla::User::match_field($cgi, {
705         '^requestee(_type)?-(\d+)$' => { 'type' => 'multi' }
706     });
707     Bugzilla::Flag::validate($bug->id, $attachment->id);
708
709     # Start a transaction in preparation for updating the attachment.
710     $dbh->bz_start_transaction();
711
712   # Quote the description and content type for use in the SQL UPDATE statement.
713   my $description = $cgi->param('description');
714   my $contenttype = $cgi->param('contenttype');
715   my $filename = $cgi->param('filename');
716   # we can detaint this way thanks to placeholders
717   trick_taint($description);
718   trick_taint($contenttype);
719   trick_taint($filename);
720
721   # Figure out when the changes were made.
722   my ($timestamp) = $dbh->selectrow_array("SELECT NOW()");
723     
724   # Update flags.  We have to do this before committing changes
725   # to attachments so that we can delete pending requests if the user
726   # is obsoleting this attachment without deleting any requests
727   # the user submits at the same time.
728   Bugzilla::Flag->process($bug, $attachment, $timestamp, $vars);
729
730   # Update the attachment record in the database.
731   $dbh->do("UPDATE  attachments 
732             SET     description = ?,
733                     mimetype    = ?,
734                     filename    = ?,
735                     ispatch     = ?,
736                     isobsolete  = ?,
737                     isprivate   = ?,
738                     modification_time = ?
739             WHERE   attach_id   = ?",
740             undef, ($description, $contenttype, $filename,
741             $cgi->param('ispatch'), $cgi->param('isobsolete'), 
742             $cgi->param('isprivate'), $timestamp, $attachment->id));
743
744   my $updated_attachment = Bugzilla::Attachment->get($attachment->id);
745   # Record changes in the activity table.
746   my $sth = $dbh->prepare('INSERT INTO bugs_activity (bug_id, attach_id, who, bug_when,
747                                                       fieldid, removed, added)
748                            VALUES (?, ?, ?, ?, ?, ?, ?)');
749
750   if ($attachment->description ne $updated_attachment->description) {
751     my $fieldid = get_field_id('attachments.description');
752     $sth->execute($bug->id, $attachment->id, $user->id, $timestamp, $fieldid,
753                   $attachment->description, $updated_attachment->description);
754   }
755   if ($attachment->contenttype ne $updated_attachment->contenttype) {
756     my $fieldid = get_field_id('attachments.mimetype');
757     $sth->execute($bug->id, $attachment->id, $user->id, $timestamp, $fieldid,
758                   $attachment->contenttype, $updated_attachment->contenttype);
759   }
760   if ($attachment->filename ne $updated_attachment->filename) {
761     my $fieldid = get_field_id('attachments.filename');
762     $sth->execute($bug->id, $attachment->id, $user->id, $timestamp, $fieldid,
763                   $attachment->filename, $updated_attachment->filename);
764   }
765   if ($attachment->ispatch != $updated_attachment->ispatch) {
766     my $fieldid = get_field_id('attachments.ispatch');
767     $sth->execute($bug->id, $attachment->id, $user->id, $timestamp, $fieldid,
768                   $attachment->ispatch, $updated_attachment->ispatch);
769   }
770   if ($attachment->isobsolete != $updated_attachment->isobsolete) {
771     my $fieldid = get_field_id('attachments.isobsolete');
772     $sth->execute($bug->id, $attachment->id, $user->id, $timestamp, $fieldid,
773                   $attachment->isobsolete, $updated_attachment->isobsolete);
774   }
775   if ($attachment->isprivate != $updated_attachment->isprivate) {
776     my $fieldid = get_field_id('attachments.isprivate');
777     $sth->execute($bug->id, $attachment->id, $user->id, $timestamp, $fieldid,
778                   $attachment->isprivate, $updated_attachment->isprivate);
779   }
780   
781   # Commit the transaction now that we are finished updating the database.
782   $dbh->bz_commit_transaction();
783
784   # Commit the comment, if any.
785   $bug->update();
786
787   # Define the variables and functions that will be passed to the UI template.
788   $vars->{'mailrecipients'} = { 'changer' => Bugzilla->user->login };
789   $vars->{'attachment'} = $attachment;
790   # We cannot reuse the $bug object as delta_ts has eventually been updated
791   # since the object was created.
792   $vars->{'bugs'} = [new Bugzilla::Bug($bug->id)];
793   $vars->{'header_done'} = 1;
794   $vars->{'use_keywords'} = 1 if Bugzilla::Keyword::keyword_count();
795
796   print $cgi->header();
797
798   # Generate and return the UI (HTML page) from the appropriate template.
799   $template->process("attachment/updated.html.tmpl", $vars)
800     || ThrowTemplateError($template->error());
801 }
802
803 # Only administrators can delete attachments.
804 sub delete_attachment {
805     my $user = Bugzilla->login(LOGIN_REQUIRED);
806     my $dbh = Bugzilla->dbh;
807
808     print $cgi->header();
809
810     $user->in_group('admin')
811       || ThrowUserError('auth_failure', {group  => 'admin',
812                                          action => 'delete',
813                                          object => 'attachment'});
814
815     Bugzilla->params->{'allow_attachment_deletion'}
816       || ThrowUserError('attachment_deletion_disabled');
817
818     # Make sure the administrator is allowed to edit this attachment.
819     my $attachment = validateID();
820     validateCanChangeBug($attachment->bug_id);
821
822     $attachment->datasize || ThrowUserError('attachment_removed');
823
824     # We don't want to let a malicious URL accidentally delete an attachment.
825     my $token = trim($cgi->param('token'));
826     if ($token) {
827         my ($creator_id, $date, $event) = Bugzilla::Token::GetTokenData($token);
828         unless ($creator_id
829                   && ($creator_id == $user->id)
830                   && ($event eq 'attachment' . $attachment->id))
831         {
832             # The token is invalid.
833             ThrowUserError('token_does_not_exist');
834         }
835
836         my $bug = new Bugzilla::Bug($attachment->bug_id);
837
838         # The token is valid. Delete the content of the attachment.
839         my $msg;
840         $vars->{'attachment'} = $attachment;
841         $vars->{'date'} = $date;
842         $vars->{'reason'} = clean_text($cgi->param('reason') || '');
843         $vars->{'mailrecipients'} = { 'changer' => $user->login };
844
845         $template->process("attachment/delete_reason.txt.tmpl", $vars, \$msg)
846           || ThrowTemplateError($template->error());
847
848         # Paste the reason provided by the admin into a comment.
849         $bug->add_comment($msg);
850
851         # If the attachment is stored locally, remove it.
852         if (-e $attachment->_get_local_filename) {
853             unlink $attachment->_get_local_filename;
854         }
855         $attachment->remove_from_db();
856
857         # Now delete the token.
858         delete_token($token);
859
860         # Insert the comment.
861         $bug->update();
862
863         # Required to display the bug the deleted attachment belongs to.
864         $vars->{'bugs'} = [$bug];
865         $vars->{'header_done'} = 1;
866         $vars->{'use_keywords'} = 1 if Bugzilla::Keyword::keyword_count();
867
868         $template->process("attachment/updated.html.tmpl", $vars)
869           || ThrowTemplateError($template->error());
870     }
871     else {
872         # Create a token.
873         $token = issue_session_token('attachment' . $attachment->id);
874
875         $vars->{'a'} = $attachment;
876         $vars->{'token'} = $token;
877
878         $template->process("attachment/confirm-delete.html.tmpl", $vars)
879           || ThrowTemplateError($template->error());
880     }
881 }