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