2002-01-20 04:44:52 +03:00
|
|
|
#!/usr/bonsaitools/bin/perl -wT
|
2001-08-31 08:19:32 +04:00
|
|
|
# -*- Mode: perl; indent-tabs-mode: nil -*-
|
|
|
|
#
|
|
|
|
# The contents of this file are subject to the Mozilla Public
|
|
|
|
# License Version 1.1 (the "License"); you may not use this file
|
|
|
|
# except in compliance with the License. You may obtain a copy of
|
|
|
|
# the License at http://www.mozilla.org/MPL/
|
|
|
|
#
|
|
|
|
# Software distributed under the License is distributed on an "AS
|
|
|
|
# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
# implied. See the License for the specific language governing
|
|
|
|
# rights and limitations under the License.
|
|
|
|
#
|
|
|
|
# The Original Code is the Bugzilla Bug Tracking System.
|
|
|
|
#
|
|
|
|
# The Initial Developer of the Original Code is Netscape Communications
|
|
|
|
# Corporation. Portions created by Netscape are
|
|
|
|
# Copyright (C) 1998 Netscape Communications Corporation. All
|
|
|
|
# Rights Reserved.
|
|
|
|
#
|
|
|
|
# Contributor(s): Terry Weissman <terry@mozilla.org>
|
|
|
|
# Myk Melez <myk@mozilla.org>
|
2002-09-21 20:57:12 +04:00
|
|
|
# Daniel Raichle <draichle@gmx.net>
|
|
|
|
# Dave Miller <justdave@syndicomm.com>
|
2001-08-31 08:19:32 +04:00
|
|
|
|
|
|
|
################################################################################
|
|
|
|
# Script Initialization
|
|
|
|
################################################################################
|
|
|
|
|
|
|
|
# Make it harder for us to do dangerous things in Perl.
|
|
|
|
use strict;
|
|
|
|
|
2002-01-20 04:44:52 +03:00
|
|
|
use lib qw(.);
|
|
|
|
|
2002-02-13 05:27:24 +03:00
|
|
|
use vars qw(
|
|
|
|
$template
|
|
|
|
$vars
|
|
|
|
);
|
|
|
|
|
2002-07-04 13:12:33 +04:00
|
|
|
# Win32 specific hack to avoid a hang when creating/showing an attachment
|
|
|
|
if ($^O eq 'MSWin32') {
|
|
|
|
binmode(STDIN);
|
|
|
|
binmode(STDOUT);
|
|
|
|
}
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
# Include the Bugzilla CGI and general utility library.
|
|
|
|
require "CGI.pl";
|
|
|
|
|
2002-09-28 22:42:54 +04:00
|
|
|
# Use these modules to handle flags.
|
|
|
|
use Bugzilla::Flag;
|
|
|
|
use Bugzilla::FlagType;
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
# Establish a connection to the database backend.
|
|
|
|
ConnectToDatabase();
|
|
|
|
|
|
|
|
# Check whether or not the user is logged in and, if so, set the $::userid
|
|
|
|
quietly_check_login();
|
|
|
|
|
|
|
|
################################################################################
|
|
|
|
# Main Body Execution
|
|
|
|
################################################################################
|
|
|
|
|
|
|
|
# All calls to this script should contain an "action" variable whose value
|
|
|
|
# determines what the user wants to do. The code below checks the value of
|
|
|
|
# that variable and runs the appropriate code.
|
|
|
|
|
|
|
|
# Determine whether to use the action specified by the user or the default.
|
|
|
|
my $action = $::FORM{'action'} || 'view';
|
|
|
|
|
|
|
|
if ($action eq "view")
|
|
|
|
{
|
|
|
|
validateID();
|
|
|
|
view();
|
|
|
|
}
|
|
|
|
elsif ($action eq "viewall")
|
|
|
|
{
|
|
|
|
ValidateBugID($::FORM{'bugid'});
|
|
|
|
viewall();
|
|
|
|
}
|
2001-10-31 02:42:22 +03:00
|
|
|
elsif ($action eq "enter")
|
|
|
|
{
|
2001-11-09 04:11:09 +03:00
|
|
|
confirm_login();
|
2001-10-31 02:42:22 +03:00
|
|
|
ValidateBugID($::FORM{'bugid'});
|
|
|
|
enter();
|
|
|
|
}
|
|
|
|
elsif ($action eq "insert")
|
|
|
|
{
|
2001-11-09 04:11:09 +03:00
|
|
|
confirm_login();
|
2001-10-31 02:42:22 +03:00
|
|
|
ValidateBugID($::FORM{'bugid'});
|
2002-03-11 10:33:03 +03:00
|
|
|
ValidateComment($::FORM{'comment'});
|
2001-10-31 02:42:22 +03:00
|
|
|
validateFilename();
|
|
|
|
validateData();
|
|
|
|
validateDescription();
|
|
|
|
validateIsPatch();
|
|
|
|
validateContentType() unless $::FORM{'ispatch'};
|
|
|
|
validateObsolete() if $::FORM{'obsolete'};
|
|
|
|
insert();
|
|
|
|
}
|
2001-08-31 08:19:32 +04:00
|
|
|
elsif ($action eq "edit")
|
|
|
|
{
|
2002-02-26 09:13:35 +03:00
|
|
|
quietly_check_login();
|
2001-08-31 08:19:32 +04:00
|
|
|
validateID();
|
2002-02-26 09:13:35 +03:00
|
|
|
validateCanEdit($::FORM{'id'});
|
2001-08-31 08:19:32 +04:00
|
|
|
edit();
|
|
|
|
}
|
|
|
|
elsif ($action eq "update")
|
|
|
|
{
|
|
|
|
confirm_login();
|
2002-03-11 10:33:03 +03:00
|
|
|
ValidateComment($::FORM{'comment'});
|
2001-08-31 08:19:32 +04:00
|
|
|
validateID();
|
2002-02-26 09:13:35 +03:00
|
|
|
validateCanEdit($::FORM{'id'});
|
2001-08-31 08:19:32 +04:00
|
|
|
validateDescription();
|
|
|
|
validateIsPatch();
|
2001-10-31 02:42:22 +03:00
|
|
|
validateContentType() unless $::FORM{'ispatch'};
|
2001-08-31 08:19:32 +04:00
|
|
|
validateIsObsolete();
|
2002-08-20 01:17:28 +04:00
|
|
|
validatePrivate();
|
2002-09-28 22:42:54 +04:00
|
|
|
Bugzilla::Flag::validate(\%::FORM);
|
|
|
|
Bugzilla::FlagType::validate(\%::FORM);
|
2001-08-31 08:19:32 +04:00
|
|
|
update();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2002-09-21 02:26:14 +04:00
|
|
|
ThrowCodeError("unknown_action");
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
exit;
|
|
|
|
|
|
|
|
################################################################################
|
|
|
|
# Data Validation / Security Authorization
|
|
|
|
################################################################################
|
|
|
|
|
|
|
|
sub validateID
|
|
|
|
{
|
2002-08-20 01:17:28 +04:00
|
|
|
# Validate the value of the "id" form field, which must contain an
|
|
|
|
# integer that is the ID of an existing attachment.
|
2001-08-31 08:19:32 +04:00
|
|
|
|
2002-09-21 02:26:14 +04:00
|
|
|
$vars->{'attach_id'} = $::FORM{'id'};
|
|
|
|
|
|
|
|
detaint_natural($::FORM{'id'})
|
|
|
|
|| ThrowUserError("invalid_attach_id");
|
2001-08-31 08:19:32 +04:00
|
|
|
|
2002-08-20 01:17:28 +04:00
|
|
|
# Make sure the attachment exists in the database.
|
|
|
|
SendSQL("SELECT bug_id, isprivate FROM attachments WHERE attach_id = $::FORM{'id'}");
|
|
|
|
MoreSQLData()
|
2002-09-21 02:26:14 +04:00
|
|
|
|| ThrowUserError("invalid_attach_id");
|
2001-08-31 08:19:32 +04:00
|
|
|
|
2002-08-20 01:17:28 +04:00
|
|
|
# Make sure the user is authorized to access this attachment's bug.
|
|
|
|
my ($bugid, $isprivate) = FetchSQLData();
|
|
|
|
ValidateBugID($bugid);
|
|
|
|
if (($isprivate > 0 ) && Param("insidergroup") && !(UserInGroup(Param("insidergroup")))) {
|
2002-09-13 02:51:50 +04:00
|
|
|
ThrowUserError("attachment_access_denied");
|
2002-08-20 01:17:28 +04:00
|
|
|
}
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|
|
|
|
|
2002-02-26 09:13:35 +03:00
|
|
|
sub validateCanEdit
|
|
|
|
{
|
|
|
|
my ($attach_id) = (@_);
|
|
|
|
|
|
|
|
# If the user is not logged in, claim that they can edit. This allows
|
|
|
|
# the edit scrren to be displayed to people who aren't logged in.
|
|
|
|
# People not logged in can't actually commit changes, because that code
|
|
|
|
# calls confirm_login, not quietly_check_login, before calling this sub
|
|
|
|
return if $::userid == 0;
|
|
|
|
|
|
|
|
# People in editbugs can edit all attachments
|
|
|
|
return if UserInGroup("editbugs");
|
|
|
|
|
|
|
|
# Bug 97729 - the submitter can edit their attachments
|
|
|
|
SendSQL("SELECT attach_id FROM attachments WHERE " .
|
|
|
|
"attach_id = $attach_id AND submitter_id = $::userid");
|
|
|
|
|
|
|
|
FetchSQLData()
|
2002-09-21 02:26:14 +04:00
|
|
|
|| ThrowUserError("illegal_attachment_edit");
|
2002-02-26 09:13:35 +03:00
|
|
|
}
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
sub validateDescription
|
|
|
|
{
|
|
|
|
$::FORM{'description'}
|
2002-09-21 02:26:14 +04:00
|
|
|
|| ThrowUserError("missing_attachment_description");
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
sub validateIsPatch
|
|
|
|
{
|
|
|
|
# Set the ispatch flag to zero if it is undefined, since the UI uses
|
|
|
|
# an HTML checkbox to represent this flag, and unchecked HTML checkboxes
|
|
|
|
# do not get sent in HTML requests.
|
|
|
|
$::FORM{'ispatch'} = $::FORM{'ispatch'} ? 1 : 0;
|
2001-10-31 02:42:22 +03:00
|
|
|
|
|
|
|
# Set the content type to text/plain if the attachment is a patch.
|
|
|
|
$::FORM{'contenttype'} = "text/plain" if $::FORM{'ispatch'};
|
|
|
|
}
|
|
|
|
|
|
|
|
sub validateContentType
|
|
|
|
{
|
|
|
|
if (!$::FORM{'contenttypemethod'})
|
|
|
|
{
|
2002-09-21 02:26:14 +04:00
|
|
|
ThrowUserError("missing_content_type_method");
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
|
|
|
elsif ($::FORM{'contenttypemethod'} eq 'autodetect')
|
|
|
|
{
|
|
|
|
# The user asked us to auto-detect the content type, so use the type
|
|
|
|
# specified in the HTTP request headers.
|
|
|
|
if ( !$::FILE{'data'}->{'contenttype'} )
|
|
|
|
{
|
2002-09-21 02:26:14 +04:00
|
|
|
ThrowUserError("missing_content_type");
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
|
|
|
$::FORM{'contenttype'} = $::FILE{'data'}->{'contenttype'};
|
|
|
|
}
|
|
|
|
elsif ($::FORM{'contenttypemethod'} eq 'list')
|
|
|
|
{
|
|
|
|
# The user selected a content type from the list, so use their selection.
|
|
|
|
$::FORM{'contenttype'} = $::FORM{'contenttypeselection'};
|
|
|
|
}
|
|
|
|
elsif ($::FORM{'contenttypemethod'} eq 'manual')
|
|
|
|
{
|
|
|
|
# The user entered a content type manually, so use their entry.
|
|
|
|
$::FORM{'contenttype'} = $::FORM{'contenttypeentry'};
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2002-09-21 02:26:14 +04:00
|
|
|
$vars->{'contenttypemethod'} = $::FORM{'contenttypemethod'};
|
|
|
|
ThrowCodeError("illegal_content_type_method");
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if ( $::FORM{'contenttype'} !~ /^(application|audio|image|message|model|multipart|text|video)\/.+$/ )
|
|
|
|
{
|
2002-09-21 02:26:14 +04:00
|
|
|
$vars->{'contenttype'} = $::FORM{'contenttype'};
|
|
|
|
ThrowUserError("invalid_content_type");
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
sub validateIsObsolete
|
|
|
|
{
|
|
|
|
# Set the isobsolete flag to zero if it is undefined, since the UI uses
|
|
|
|
# an HTML checkbox to represent this flag, and unchecked HTML checkboxes
|
|
|
|
# do not get sent in HTML requests.
|
|
|
|
$::FORM{'isobsolete'} = $::FORM{'isobsolete'} ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2002-08-20 01:17:28 +04:00
|
|
|
sub validatePrivate
|
|
|
|
{
|
|
|
|
# Set the isprivate flag to zero if it is undefined, since the UI uses
|
|
|
|
# an HTML checkbox to represent this flag, and unchecked HTML checkboxes
|
|
|
|
# do not get sent in HTML requests.
|
|
|
|
$::FORM{'isprivate'} = $::FORM{'isprivate'} ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2001-10-31 02:42:22 +03:00
|
|
|
sub validateData
|
|
|
|
{
|
|
|
|
$::FORM{'data'}
|
2002-09-21 02:26:14 +04:00
|
|
|
|| ThrowUserError("zero_length_file");
|
2001-10-31 02:42:22 +03:00
|
|
|
|
|
|
|
my $len = length($::FORM{'data'});
|
|
|
|
|
|
|
|
my $maxpatchsize = Param('maxpatchsize');
|
|
|
|
my $maxattachmentsize = Param('maxattachmentsize');
|
|
|
|
|
|
|
|
# Makes sure the attachment does not exceed either the "maxpatchsize" or
|
|
|
|
# the "maxattachmentsize" parameter.
|
|
|
|
if ( $::FORM{'ispatch'} && $maxpatchsize && $len > $maxpatchsize*1024 )
|
|
|
|
{
|
2002-09-21 02:26:14 +04:00
|
|
|
$vars->{'filesize'} = sprintf("%.0f", $len/1024);
|
|
|
|
ThrowUserError("patch_too_large");
|
2001-10-31 02:42:22 +03:00
|
|
|
} elsif ( !$::FORM{'ispatch'} && $maxattachmentsize && $len > $maxattachmentsize*1024 ) {
|
2002-09-21 02:26:14 +04:00
|
|
|
$vars->{'filesize'} = sprintf("%.0f", $len/1024);
|
|
|
|
ThrowUserError("file_too_large");
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sub validateFilename
|
|
|
|
{
|
|
|
|
defined $::FILE{'data'}
|
2002-09-21 02:26:14 +04:00
|
|
|
|| ThrowUserError("file_not_specified");
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
sub validateObsolete
|
|
|
|
{
|
|
|
|
# Make sure the attachment id is valid and the user has permissions to view
|
|
|
|
# the bug to which it is attached.
|
|
|
|
foreach my $attachid (@{$::MFORM{'obsolete'}}) {
|
2002-09-21 02:26:14 +04:00
|
|
|
$vars->{'attach_id'} = $attachid;
|
|
|
|
|
2002-02-05 03:11:48 +03:00
|
|
|
detaint_natural($attachid)
|
2002-09-21 02:26:14 +04:00
|
|
|
|| ThrowCodeError("invalid_attach_id_to_obsolete");
|
2001-10-31 02:42:22 +03:00
|
|
|
|
|
|
|
SendSQL("SELECT bug_id, isobsolete, description
|
|
|
|
FROM attachments WHERE attach_id = $attachid");
|
|
|
|
|
|
|
|
# Make sure the attachment exists in the database.
|
|
|
|
MoreSQLData()
|
2002-09-21 02:26:14 +04:00
|
|
|
|| ThrowUserError("invalid_attach_id");
|
2001-10-31 02:42:22 +03:00
|
|
|
|
|
|
|
my ($bugid, $isobsolete, $description) = FetchSQLData();
|
|
|
|
|
2002-09-21 02:26:14 +04:00
|
|
|
$vars->{'description'} = $description;
|
|
|
|
|
2001-10-31 02:42:22 +03:00
|
|
|
if ($bugid != $::FORM{'bugid'})
|
|
|
|
{
|
2002-09-21 02:26:14 +04:00
|
|
|
$vars->{'my_bug_id'} = $::FORM{'bugid'};
|
|
|
|
$vars->{'attach_bug_id'} = $bugid;
|
|
|
|
ThrowCodeError("mismatched_bug_ids_on_obsolete");
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if ( $isobsolete )
|
|
|
|
{
|
2002-09-21 02:26:14 +04:00
|
|
|
ThrowCodeError("attachment_already_obsolete");
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
2002-02-26 09:13:35 +03:00
|
|
|
|
|
|
|
# Check that the user can modify this attachment
|
|
|
|
validateCanEdit($attachid);
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
################################################################################
|
|
|
|
# Functions
|
|
|
|
################################################################################
|
|
|
|
|
|
|
|
sub view
|
|
|
|
{
|
2002-08-20 01:17:28 +04:00
|
|
|
# Display an attachment.
|
2001-08-31 08:19:32 +04:00
|
|
|
|
2002-08-20 01:17:28 +04:00
|
|
|
# Retrieve the attachment content and its content type from the database.
|
2002-09-21 20:57:12 +04:00
|
|
|
SendSQL("SELECT mimetype, filename, thedata FROM attachments WHERE attach_id = $::FORM{'id'}");
|
|
|
|
my ($contenttype, $filename, $thedata) = FetchSQLData();
|
|
|
|
|
2002-08-20 01:17:28 +04:00
|
|
|
# Return the appropriate HTTP response headers.
|
2002-09-21 20:57:12 +04:00
|
|
|
$filename =~ s/^.*[\/\\]//;
|
|
|
|
my $filesize = length($thedata);
|
|
|
|
print qq{Content-Type: $contenttype; name="$filename"\n};
|
2002-09-28 08:10:27 +04:00
|
|
|
print qq{Content-Disposition: inline; filename=$filename\n};
|
2002-09-21 20:57:12 +04:00
|
|
|
print qq{Content-Length: $filesize\n};
|
|
|
|
print qq{\n$thedata};
|
2001-08-31 08:19:32 +04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
sub viewall
|
|
|
|
{
|
|
|
|
# Display all attachments for a given bug in a series of IFRAMEs within one HTML page.
|
|
|
|
|
|
|
|
# Retrieve the attachments from the database and write them into an array
|
|
|
|
# of hashes where each hash represents one attachment.
|
2002-08-20 01:17:28 +04:00
|
|
|
my $privacy = "";
|
|
|
|
if (Param("insidergroup") && !(UserInGroup(Param("insidergroup")))) {
|
|
|
|
$privacy = "AND isprivate < 1 ";
|
|
|
|
}
|
|
|
|
SendSQL("SELECT attach_id, creation_ts, mimetype, description,
|
|
|
|
ispatch, isobsolete, isprivate
|
|
|
|
FROM attachments WHERE bug_id = $::FORM{'bugid'} $privacy
|
|
|
|
ORDER BY attach_id");
|
2001-08-31 08:19:32 +04:00
|
|
|
my @attachments; # the attachments array
|
2001-10-31 02:42:22 +03:00
|
|
|
while (MoreSQLData())
|
|
|
|
{
|
2001-08-31 08:19:32 +04:00
|
|
|
my %a; # the attachment hash
|
2001-10-31 02:42:22 +03:00
|
|
|
($a{'attachid'}, $a{'date'}, $a{'contenttype'},
|
2002-08-20 01:17:28 +04:00
|
|
|
$a{'description'}, $a{'ispatch'}, $a{'isobsolete'}, $a{'isprivate'}) = FetchSQLData();
|
2001-08-31 08:19:32 +04:00
|
|
|
|
|
|
|
# Flag attachments as to whether or not they can be viewed (as opposed to
|
|
|
|
# being downloaded). Currently I decide they are viewable if their MIME type
|
|
|
|
# is either text/*, image/*, or application/vnd.mozilla.*.
|
|
|
|
# !!! Yuck, what an ugly hack. Fix it!
|
2001-10-31 02:42:22 +03:00
|
|
|
$a{'isviewable'} = ( $a{'contenttype'} =~ /^(text|image|application\/vnd\.mozilla\.)/ );
|
2001-08-31 08:19:32 +04:00
|
|
|
|
|
|
|
# Add the hash representing the attachment to the array of attachments.
|
|
|
|
push @attachments, \%a;
|
|
|
|
}
|
|
|
|
|
|
|
|
# Retrieve the bug summary for displaying on screen.
|
|
|
|
SendSQL("SELECT short_desc FROM bugs WHERE bug_id = $::FORM{'bugid'}");
|
|
|
|
my ($bugsummary) = FetchSQLData();
|
|
|
|
|
|
|
|
# Define the variables and functions that will be passed to the UI template.
|
|
|
|
$vars->{'bugid'} = $::FORM{'bugid'};
|
|
|
|
$vars->{'bugsummary'} = $bugsummary;
|
|
|
|
$vars->{'attachments'} = \@attachments;
|
|
|
|
|
|
|
|
# Return the appropriate HTTP response headers.
|
|
|
|
print "Content-Type: text/html\n\n";
|
|
|
|
|
|
|
|
# Generate and return the UI (HTML page) from the appropriate template.
|
2002-04-24 11:24:50 +04:00
|
|
|
$template->process("attachment/show-multiple.html.tmpl", $vars)
|
|
|
|
|| ThrowTemplateError($template->error());
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-10-31 02:42:22 +03:00
|
|
|
sub enter
|
|
|
|
{
|
|
|
|
# Display a form for entering a new attachment.
|
|
|
|
|
2002-02-26 09:13:35 +03:00
|
|
|
# Retrieve the attachments the user can edit from the database and write
|
|
|
|
# them into an array of hashes where each hash represents one attachment.
|
|
|
|
my $canEdit = "";
|
|
|
|
if (!UserInGroup("editbugs")) {
|
|
|
|
$canEdit = "AND submitter_id = $::userid";
|
|
|
|
}
|
2002-08-20 01:17:28 +04:00
|
|
|
SendSQL("SELECT attach_id, description, isprivate
|
2001-10-31 02:42:22 +03:00
|
|
|
FROM attachments
|
|
|
|
WHERE bug_id = $::FORM{'bugid'}
|
2002-02-26 09:13:35 +03:00
|
|
|
AND isobsolete = 0 $canEdit
|
2001-10-31 02:42:22 +03:00
|
|
|
ORDER BY attach_id");
|
|
|
|
my @attachments; # the attachments array
|
|
|
|
while ( MoreSQLData() ) {
|
|
|
|
my %a; # the attachment hash
|
2002-08-20 01:17:28 +04:00
|
|
|
($a{'id'}, $a{'description'}, $a{'isprivate'}) = FetchSQLData();
|
2001-10-31 02:42:22 +03:00
|
|
|
|
|
|
|
# Add the hash representing the attachment to the array of attachments.
|
|
|
|
push @attachments, \%a;
|
|
|
|
}
|
|
|
|
|
|
|
|
# Retrieve the bug summary for displaying on screen.
|
|
|
|
SendSQL("SELECT short_desc FROM bugs WHERE bug_id = $::FORM{'bugid'}");
|
|
|
|
my ($bugsummary) = FetchSQLData();
|
|
|
|
|
|
|
|
# Define the variables and functions that will be passed to the UI template.
|
|
|
|
$vars->{'bugid'} = $::FORM{'bugid'};
|
|
|
|
$vars->{'bugsummary'} = $bugsummary;
|
|
|
|
$vars->{'attachments'} = \@attachments;
|
|
|
|
|
|
|
|
# Return the appropriate HTTP response headers.
|
|
|
|
print "Content-Type: text/html\n\n";
|
|
|
|
|
|
|
|
# Generate and return the UI (HTML page) from the appropriate template.
|
2002-04-24 11:24:50 +04:00
|
|
|
$template->process("attachment/create.html.tmpl", $vars)
|
|
|
|
|| ThrowTemplateError($template->error());
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
sub insert
|
|
|
|
{
|
|
|
|
# Insert a new attachment into the database.
|
|
|
|
|
|
|
|
# Escape characters in strings that will be used in SQL statements.
|
|
|
|
my $filename = SqlQuote($::FILE{'data'}->{'filename'});
|
|
|
|
my $description = SqlQuote($::FORM{'description'});
|
|
|
|
my $contenttype = SqlQuote($::FORM{'contenttype'});
|
|
|
|
my $thedata = SqlQuote($::FORM{'data'});
|
2002-08-20 01:17:28 +04:00
|
|
|
my $isprivate = $::FORM{'isprivate'} ? 1 : 0;
|
2001-10-31 02:42:22 +03:00
|
|
|
|
|
|
|
# Insert the attachment into the database.
|
2002-08-20 01:17:28 +04:00
|
|
|
SendSQL("INSERT INTO attachments (bug_id, creation_ts, filename, description, mimetype, ispatch, isprivate, submitter_id, thedata)
|
|
|
|
VALUES ($::FORM{'bugid'}, now(), $filename, $description, $contenttype, $::FORM{'ispatch'}, $isprivate, $::userid, $thedata)");
|
2001-10-31 02:42:22 +03:00
|
|
|
|
|
|
|
# Retrieve the ID of the newly created attachment record.
|
|
|
|
SendSQL("SELECT LAST_INSERT_ID()");
|
|
|
|
my $attachid = FetchOneColumn();
|
|
|
|
|
|
|
|
# Insert a comment about the new attachment into the database.
|
2001-11-20 05:59:55 +03:00
|
|
|
my $comment = "Created an attachment (id=$attachid)\n$::FORM{'description'}\n";
|
2001-10-31 02:42:22 +03:00
|
|
|
$comment .= ("\n" . $::FORM{'comment'}) if $::FORM{'comment'};
|
|
|
|
|
|
|
|
use Text::Wrap;
|
|
|
|
$Text::Wrap::columns = 80;
|
|
|
|
$Text::Wrap::huge = 'overflow';
|
|
|
|
$comment = Text::Wrap::wrap('', '', $comment);
|
|
|
|
|
|
|
|
AppendComment($::FORM{'bugid'},
|
|
|
|
$::COOKIE{"Bugzilla_login"},
|
2002-08-20 01:17:28 +04:00
|
|
|
$comment,
|
|
|
|
$isprivate);
|
2001-10-31 02:42:22 +03:00
|
|
|
|
|
|
|
# Make existing attachments obsolete.
|
|
|
|
my $fieldid = GetFieldID('attachments.isobsolete');
|
2002-09-28 22:42:54 +04:00
|
|
|
foreach my $obsolete_id (@{$::MFORM{'obsolete'}}) {
|
|
|
|
SendSQL("UPDATE attachments SET isobsolete = 1 WHERE attach_id = $obsolete_id");
|
2002-08-20 01:17:28 +04:00
|
|
|
SendSQL("INSERT INTO bugs_activity (bug_id, attach_id, who, bug_when, fieldid, removed, added)
|
2002-09-28 22:42:54 +04:00
|
|
|
VALUES ($::FORM{'bugid'}, $obsolete_id, $::userid, NOW(), $fieldid, '0', '1')");
|
|
|
|
# If the obsolete attachment has pending flags, migrate them to the new attachment.
|
|
|
|
if (Bugzilla::Flag::count({ 'attach_id' => $obsolete_id , 'status' => 'pending' })) {
|
|
|
|
Bugzilla::Flag::migrate($obsolete_id, $attachid);
|
|
|
|
}
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
# Send mail to let people know the attachment has been created. Uses a
|
|
|
|
# special syntax of the "open" and "exec" commands to capture the output of
|
|
|
|
# "processmail", which "system" doesn't allow, without running the command
|
|
|
|
# through a shell, which backticks (``) do.
|
|
|
|
#system ("./processmail", $bugid , $::userid);
|
|
|
|
#my $mailresults = `./processmail $bugid $::userid`;
|
|
|
|
my $mailresults = '';
|
|
|
|
open(PMAIL, "-|") or exec('./processmail', $::FORM{'bugid'}, $::COOKIE{'Bugzilla_login'});
|
|
|
|
$mailresults .= $_ while <PMAIL>;
|
|
|
|
close(PMAIL);
|
|
|
|
|
|
|
|
# Define the variables and functions that will be passed to the UI template.
|
|
|
|
$vars->{'bugid'} = $::FORM{'bugid'};
|
|
|
|
$vars->{'attachid'} = $attachid;
|
|
|
|
$vars->{'description'} = $description;
|
|
|
|
$vars->{'mailresults'} = $mailresults;
|
|
|
|
$vars->{'contenttypemethod'} = $::FORM{'contenttypemethod'};
|
|
|
|
$vars->{'contenttype'} = $::FORM{'contenttype'};
|
|
|
|
|
|
|
|
# Return the appropriate HTTP response headers.
|
|
|
|
print "Content-Type: text/html\n\n";
|
|
|
|
|
|
|
|
# Generate and return the UI (HTML page) from the appropriate template.
|
2002-04-24 11:24:50 +04:00
|
|
|
$template->process("attachment/created.html.tmpl", $vars)
|
|
|
|
|| ThrowTemplateError($template->error());
|
2001-10-31 02:42:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
sub edit
|
|
|
|
{
|
2002-02-26 09:13:35 +03:00
|
|
|
# Edit an attachment record. Users with "editbugs" privileges, (or the
|
|
|
|
# original attachment's submitter) can edit the attachment's description,
|
|
|
|
# content type, ispatch and isobsolete flags, and statuses, and they can
|
|
|
|
# also submit a comment that appears in the bug.
|
2001-08-31 08:19:32 +04:00
|
|
|
# Users cannot edit the content of the attachment itself.
|
|
|
|
|
|
|
|
# Retrieve the attachment from the database.
|
2002-09-21 20:57:12 +04:00
|
|
|
SendSQL("SELECT description, mimetype, filename, bug_id, ispatch, isobsolete, isprivate
|
2001-08-31 08:19:32 +04:00
|
|
|
FROM attachments WHERE attach_id = $::FORM{'id'}");
|
2002-09-21 20:57:12 +04:00
|
|
|
my ($description, $contenttype, $filename, $bugid, $ispatch, $isobsolete, $isprivate) = FetchSQLData();
|
2001-08-31 08:19:32 +04:00
|
|
|
|
|
|
|
# Flag attachment as to whether or not it can be viewed (as opposed to
|
2001-10-31 02:42:22 +03:00
|
|
|
# being downloaded). Currently I decide it is viewable if its content
|
|
|
|
# type is either text/.* or application/vnd.mozilla.*.
|
2001-08-31 08:19:32 +04:00
|
|
|
# !!! Yuck, what an ugly hack. Fix it!
|
2001-10-31 02:42:22 +03:00
|
|
|
my $isviewable = ( $contenttype =~ /^(text|image|application\/vnd\.mozilla\.)/ );
|
2001-08-31 08:19:32 +04:00
|
|
|
|
|
|
|
# Retrieve a list of attachments for this bug as well as a summary of the bug
|
|
|
|
# to use in a navigation bar across the top of the screen.
|
|
|
|
SendSQL("SELECT attach_id FROM attachments WHERE bug_id = $bugid ORDER BY attach_id");
|
|
|
|
my @bugattachments;
|
|
|
|
push(@bugattachments, FetchSQLData()) while (MoreSQLData());
|
|
|
|
SendSQL("SELECT short_desc FROM bugs WHERE bug_id = $bugid");
|
|
|
|
my ($bugsummary) = FetchSQLData();
|
2002-09-28 22:42:54 +04:00
|
|
|
|
|
|
|
# Get a list of flag types that can be set for this attachment.
|
|
|
|
SendSQL("SELECT product_id, component_id FROM bugs WHERE bug_id = $bugid");
|
|
|
|
my ($product_id, $component_id) = FetchSQLData();
|
|
|
|
my $flag_types = Bugzilla::FlagType::match({ 'target_type' => 'attachment' ,
|
|
|
|
'product_id' => $product_id ,
|
|
|
|
'component_id' => $component_id ,
|
|
|
|
'is_active' => 1});
|
|
|
|
foreach my $flag_type (@$flag_types) {
|
|
|
|
$flag_type->{'flags'} = Bugzilla::Flag::match({ 'type_id' => $flag_type->{'id'},
|
|
|
|
'attach_id' => $::FORM{'id'} });
|
|
|
|
}
|
|
|
|
$vars->{'flag_types'} = $flag_types;
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
# Define the variables and functions that will be passed to the UI template.
|
|
|
|
$vars->{'attachid'} = $::FORM{'id'};
|
|
|
|
$vars->{'description'} = $description;
|
2001-10-31 02:42:22 +03:00
|
|
|
$vars->{'contenttype'} = $contenttype;
|
2002-09-21 20:57:12 +04:00
|
|
|
$vars->{'filename'} = $filename;
|
2001-08-31 08:19:32 +04:00
|
|
|
$vars->{'bugid'} = $bugid;
|
|
|
|
$vars->{'bugsummary'} = $bugsummary;
|
|
|
|
$vars->{'ispatch'} = $ispatch;
|
|
|
|
$vars->{'isobsolete'} = $isobsolete;
|
2002-08-20 01:17:28 +04:00
|
|
|
$vars->{'isprivate'} = $isprivate;
|
2001-08-31 08:19:32 +04:00
|
|
|
$vars->{'isviewable'} = $isviewable;
|
|
|
|
$vars->{'attachments'} = \@bugattachments;
|
|
|
|
|
|
|
|
# Return the appropriate HTTP response headers.
|
|
|
|
print "Content-Type: text/html\n\n";
|
|
|
|
|
|
|
|
# Generate and return the UI (HTML page) from the appropriate template.
|
2002-04-24 11:24:50 +04:00
|
|
|
$template->process("attachment/edit.html.tmpl", $vars)
|
|
|
|
|| ThrowTemplateError($template->error());
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
sub update
|
|
|
|
{
|
2002-09-28 22:42:54 +04:00
|
|
|
# Updates an attachment record.
|
2001-08-31 08:19:32 +04:00
|
|
|
|
|
|
|
# Get the bug ID for the bug to which this attachment is attached.
|
|
|
|
SendSQL("SELECT bug_id FROM attachments WHERE attach_id = $::FORM{'id'}");
|
2002-09-21 02:26:14 +04:00
|
|
|
my $bugid = FetchSQLData();
|
|
|
|
unless ($bugid)
|
|
|
|
{
|
|
|
|
$vars->{'bug_id'} = $bugid;
|
|
|
|
ThrowUserError("invalid_bug_id");
|
|
|
|
}
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
# Lock database tables in preparation for updating the attachment.
|
2002-09-28 22:42:54 +04:00
|
|
|
SendSQL("LOCK TABLES attachments WRITE , flags WRITE , " .
|
|
|
|
"flagtypes READ , fielddefs READ , bugs_activity WRITE, " .
|
|
|
|
"flaginclusions AS i READ, flagexclusions AS e READ, " .
|
|
|
|
"bugs READ, profiles READ");
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
# Get a copy of the attachment record before we make changes
|
|
|
|
# so we can record those changes in the activity table.
|
2002-09-21 20:57:12 +04:00
|
|
|
SendSQL("SELECT description, mimetype, filename, ispatch, isobsolete, isprivate
|
2001-08-31 08:19:32 +04:00
|
|
|
FROM attachments WHERE attach_id = $::FORM{'id'}");
|
2002-09-21 20:57:12 +04:00
|
|
|
my ($olddescription, $oldcontenttype, $oldfilename, $oldispatch,
|
|
|
|
$oldisobsolete, $oldisprivate) = FetchSQLData();
|
2001-08-31 08:19:32 +04:00
|
|
|
|
2001-10-31 02:42:22 +03:00
|
|
|
# Quote the description and content type for use in the SQL UPDATE statement.
|
2001-08-31 08:19:32 +04:00
|
|
|
my $quoteddescription = SqlQuote($::FORM{'description'});
|
2001-10-31 02:42:22 +03:00
|
|
|
my $quotedcontenttype = SqlQuote($::FORM{'contenttype'});
|
2002-09-21 20:57:12 +04:00
|
|
|
my $quotedfilename = SqlQuote($::FORM{'filename'});
|
2001-08-31 08:19:32 +04:00
|
|
|
|
|
|
|
# Update the attachment record in the database.
|
|
|
|
# Sets the creation timestamp to itself to avoid it being updated automatically.
|
|
|
|
SendSQL("UPDATE attachments
|
|
|
|
SET description = $quoteddescription ,
|
2001-10-31 02:42:22 +03:00
|
|
|
mimetype = $quotedcontenttype ,
|
2002-09-21 20:57:12 +04:00
|
|
|
filename = $quotedfilename ,
|
2001-08-31 08:19:32 +04:00
|
|
|
ispatch = $::FORM{'ispatch'} ,
|
2002-08-24 18:51:27 +04:00
|
|
|
isobsolete = $::FORM{'isobsolete'} ,
|
|
|
|
isprivate = $::FORM{'isprivate'}
|
2001-08-31 08:19:32 +04:00
|
|
|
WHERE attach_id = $::FORM{'id'}
|
|
|
|
");
|
|
|
|
|
2002-09-28 22:42:54 +04:00
|
|
|
# Figure out when the changes were made.
|
|
|
|
SendSQL("SELECT NOW()");
|
|
|
|
my $timestamp = FetchOneColumn();
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
# Record changes in the activity table.
|
2002-09-28 22:42:54 +04:00
|
|
|
my $sql_timestamp = SqlQuote($timestamp);
|
2001-08-31 08:19:32 +04:00
|
|
|
if ($olddescription ne $::FORM{'description'}) {
|
|
|
|
my $quotedolddescription = SqlQuote($olddescription);
|
|
|
|
my $fieldid = GetFieldID('attachments.description');
|
|
|
|
SendSQL("INSERT INTO bugs_activity (bug_id, attach_id, who, bug_when, fieldid, removed, added)
|
2002-09-28 22:42:54 +04:00
|
|
|
VALUES ($bugid, $::FORM{'id'}, $::userid, $sql_timestamp, $fieldid, $quotedolddescription, $quoteddescription)");
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|
2001-10-31 02:42:22 +03:00
|
|
|
if ($oldcontenttype ne $::FORM{'contenttype'}) {
|
|
|
|
my $quotedoldcontenttype = SqlQuote($oldcontenttype);
|
2001-08-31 08:19:32 +04:00
|
|
|
my $fieldid = GetFieldID('attachments.mimetype');
|
|
|
|
SendSQL("INSERT INTO bugs_activity (bug_id, attach_id, who, bug_when, fieldid, removed, added)
|
2002-09-28 22:42:54 +04:00
|
|
|
VALUES ($bugid, $::FORM{'id'}, $::userid, $sql_timestamp, $fieldid, $quotedoldcontenttype, $quotedcontenttype)");
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|
2002-09-21 20:57:12 +04:00
|
|
|
if ($oldfilename ne $::FORM{'filename'}) {
|
|
|
|
my $quotedoldfilename = SqlQuote($oldfilename);
|
|
|
|
my $fieldid = GetFieldID('attachments.filename');
|
|
|
|
SendSQL("INSERT INTO bugs_activity (bug_id, attach_id, who, bug_when, fieldid, removed, added)
|
|
|
|
VALUES ($bugid, $::FORM{'id'}, $::userid, NOW(), $fieldid, $quotedoldfilename, $quotedfilename)");
|
|
|
|
}
|
2001-08-31 08:19:32 +04:00
|
|
|
if ($oldispatch ne $::FORM{'ispatch'}) {
|
|
|
|
my $fieldid = GetFieldID('attachments.ispatch');
|
|
|
|
SendSQL("INSERT INTO bugs_activity (bug_id, attach_id, who, bug_when, fieldid, removed, added)
|
2002-09-28 22:42:54 +04:00
|
|
|
VALUES ($bugid, $::FORM{'id'}, $::userid, $sql_timestamp, $fieldid, $oldispatch, $::FORM{'ispatch'})");
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|
|
|
|
if ($oldisobsolete ne $::FORM{'isobsolete'}) {
|
|
|
|
my $fieldid = GetFieldID('attachments.isobsolete');
|
|
|
|
SendSQL("INSERT INTO bugs_activity (bug_id, attach_id, who, bug_when, fieldid, removed, added)
|
2002-09-28 22:42:54 +04:00
|
|
|
VALUES ($bugid, $::FORM{'id'}, $::userid, $sql_timestamp, $fieldid, $oldisobsolete, $::FORM{'isobsolete'})");
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|
2002-08-20 01:17:28 +04:00
|
|
|
if ($oldisprivate ne $::FORM{'isprivate'}) {
|
|
|
|
my $fieldid = GetFieldID('attachments.isprivate');
|
|
|
|
SendSQL("INSERT INTO bugs_activity (bug_id, attach_id, who, bug_when, fieldid, removed, added)
|
|
|
|
VALUES ($bugid, $::FORM{'id'}, $::userid, NOW(), $fieldid, $oldisprivate, $::FORM{'isprivate'})");
|
|
|
|
}
|
2002-09-28 22:42:54 +04:00
|
|
|
|
|
|
|
# Update flags.
|
|
|
|
my $target = Bugzilla::Flag::GetTarget(undef, $::FORM{'id'});
|
|
|
|
Bugzilla::Flag::process($target, $timestamp, \%::FORM);
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
# Unlock all database tables now that we are finished updating the database.
|
|
|
|
SendSQL("UNLOCK TABLES");
|
|
|
|
|
|
|
|
# If the user submitted a comment while editing the attachment,
|
|
|
|
# add the comment to the bug.
|
|
|
|
if ( $::FORM{'comment'} )
|
|
|
|
{
|
2001-10-11 06:17:58 +04:00
|
|
|
use Text::Wrap;
|
|
|
|
$Text::Wrap::columns = 80;
|
|
|
|
$Text::Wrap::huge = 'wrap';
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
# Append a string to the comment to let users know that the comment came from
|
|
|
|
# the "edit attachment" screen.
|
|
|
|
my $comment = qq|(From update of attachment $::FORM{'id'})\n| . $::FORM{'comment'};
|
|
|
|
|
2001-10-11 06:17:58 +04:00
|
|
|
my $wrappedcomment = "";
|
|
|
|
foreach my $line (split(/\r\n|\r|\n/, $comment))
|
|
|
|
{
|
|
|
|
if ( $line =~ /^>/ )
|
|
|
|
{
|
|
|
|
$wrappedcomment .= $line . "\n";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
$wrappedcomment .= wrap('', '', $line) . "\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
# Get the user's login name since the AppendComment function needs it.
|
|
|
|
my $who = DBID_to_name($::userid);
|
|
|
|
# Mention $::userid again so Perl doesn't give me a warning about it.
|
|
|
|
my $neverused = $::userid;
|
|
|
|
|
|
|
|
# Append the comment to the list of comments in the database.
|
2002-09-28 22:42:54 +04:00
|
|
|
AppendComment($bugid, $who, $wrappedcomment, $::FORM{'isprivate'}, $timestamp);
|
2001-08-31 08:19:32 +04:00
|
|
|
|
|
|
|
}
|
2002-09-28 22:42:54 +04:00
|
|
|
|
2001-08-31 08:19:32 +04:00
|
|
|
# Send mail to let people know the bug has changed. Uses a special syntax
|
|
|
|
# of the "open" and "exec" commands to capture the output of "processmail",
|
|
|
|
# which "system" doesn't allow, without running the command through a shell,
|
|
|
|
# which backticks (``) do.
|
|
|
|
#system ("./processmail", $bugid , $::userid);
|
|
|
|
#my $mailresults = `./processmail $bugid $::userid`;
|
|
|
|
my $mailresults = '';
|
2001-09-01 01:40:33 +04:00
|
|
|
open(PMAIL, "-|") or exec('./processmail', $bugid, DBID_to_name($::userid));
|
2001-08-31 08:19:32 +04:00
|
|
|
$mailresults .= $_ while <PMAIL>;
|
|
|
|
close(PMAIL);
|
|
|
|
|
|
|
|
# Define the variables and functions that will be passed to the UI template.
|
|
|
|
$vars->{'attachid'} = $::FORM{'id'};
|
|
|
|
$vars->{'bugid'} = $bugid;
|
|
|
|
$vars->{'mailresults'} = $mailresults;
|
|
|
|
|
|
|
|
# Return the appropriate HTTP response headers.
|
|
|
|
print "Content-Type: text/html\n\n";
|
|
|
|
|
|
|
|
# Generate and return the UI (HTML page) from the appropriate template.
|
2002-04-24 11:24:50 +04:00
|
|
|
$template->process("attachment/updated.html.tmpl", $vars)
|
|
|
|
|| ThrowTemplateError($template->error());
|
2001-08-31 08:19:32 +04:00
|
|
|
}
|