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