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