view release on metacpan or search on metacpan
lib/Amazon/SES.pm view on Meta::CPAN
multi method send(Str :$from,
Str :$body?,
Str :$body_html?,
Str :$to,
Str :$subject?,
Str :$charset = "UTF-8",
Str :$return_path?,
) {
$to = [$to] unless ref($to);
defined($body) || defined($body_html) || die("No body specified");
my %call_args = (
'Message.Subject.Data' => $subject,
'Message.Subject.Charset' => $charset,
'Source' => $from
);
if (defined($body)) {
$call_args{'Message.Body.Text.Data'} = $body;
$call_args{'Message.Body.Text.Charset'} = $charset;
}
if (defined($body_html)) {
$call_args{'Message.Body.Html.Data'} = $body_html;
$call_args{'Message.Body.Html.Charset'} = $charset;
}
if (defined($return_path)) {
$call_args{'ReturnPath'} = $return_path;
}
lib/Amazon/SES.pm view on Meta::CPAN
die $r->error_message;
}
You may provide an alternate html content by passing C<body_html> header.
C<charset> of the e-mail is set to 'UTF-8'. As of this writing I didn't make any way to affect this.
Success calls also return a C<message_id>, which can be accessed using a shortcut C<$r->message_id> syntax. See L<Response class|Amazon::SES::Response>.
Sample successful response looks like this in JSON:
view release on metacpan or search on metacpan
lib/Amazon/SQS/Client.pm view on Meta::CPAN
my $url = $queueUrl;
my $ua = $self->get_UserAgent;
my $request = HTTP::Request->new( POST => $url );
$request->content_type('application/x-www-form-urlencoded; charset=utf-8');
my $data = $EMPTY;
foreach my $parameterName ( keys %{$parameters} ) {
no warnings 'uninitialized'; ## no critic
view release on metacpan or search on metacpan
lib/Amazon/SQS/Simple/AnyEvent.pm view on Meta::CPAN
}
};
if ($post_request) {
my $headers = {
'Content-Type' => 'application/x-www-form-urlencoded;charset=utf-8',
'Content' => $query,
@auth_headers,
};
http_post($url, headers => $headers, %http_opts, $on_response);
}
else {
my $headers = {
"Content-Type" => "text/plain;charset=utf-8",
@auth_headers,
};
http_get("$url/?$query", headers => $headers, %http_opts, $on_response);
}
view release on metacpan or search on metacpan
lib/Amazon/SQS/Simple/Base.pm view on Meta::CPAN
my $date = strftime('%Y%m%d', gmtime($now));
$req->protocol('HTTP/1.1');
$req->header('Date' => $http_date);
$req->header('x-amz-target', 'AmazonSQSv20121105.' . $params->{Action});
$req->header('content-type' => 'application/x-www-form-urlencoded;charset=utf-8');
if ($self->{UseIAMRole}) {
my $creds = VM::EC2::Security::CredentialCache->get();
defined($creds) || die("Unable to retrieve IAM role credentials");
$self->{AWSAccessKeyId} = $creds->accessKeyId;
view release on metacpan or search on metacpan
lib/Ambrosia/CommonGatewayInterface/ApacheRequest.pm view on Meta::CPAN
sub prepare_header
{
my %params = @_;
my @headers = ();
my $type = 'Content-Type: text/html';
my $charset = '';
my $date;
my $nph;
my $status;
my $no_cache;
lib/Ambrosia/CommonGatewayInterface/ApacheRequest.pm view on Meta::CPAN
{
$type = 'Content-Type: ' . $params{$_};
}
elsif( $k eq 'CHARSET' )
{
$charset = $params{$_};
}
elsif( $k eq 'PRAGMA')
{
$no_cache = $params{$_};
}
lib/Ambrosia/CommonGatewayInterface/ApacheRequest.pm view on Meta::CPAN
if ( defined $nph )
{
$nph .= ($status || '200 OK') . 'Server: ' . $ENV{SERVER_SOFTWARE};
}
if ($charset && $type !~ /\bcharset\b/)
{
$type .= '; charset=' . $charset;
}
push @headers, $type;
if ( $date )
view release on metacpan or search on metacpan
factpacks/Linux.fact view on Meta::CPAN
libtcp++ => <reply> $who, C++ class library to create TCP/IP clients/servers. URL: http://www.sashanet.com/internet/download.html
libtiff => <reply> $who, Library for manipulation of TIFF (Tag Image File Format) images.. URL: http://www.libtiff.org/
Libtool => <reply> $who, GNU libtool is a generic library support script. URL: http://www.gnu.org/software/libtool/
Libundo => <reply> $who, Undo/redo management library. URL: http://undo.xnot.com/
libungif => <reply> $who, A library for reading and writing gif images without LZW compression. URL: http://prtr-13.ucsc.edu/~badger/software/libungif.shtml
libunicode => <reply> $who, Library of unicode string functions and charset converters. URL: http://www.bowerbird.com.au/libunicode/
libutf-8 => <reply> $who, Library of i18n routines for UTF-8 encoding/decoding. URL: http://www.whizkidtech.net/i18n/
LibVRML97/Lookat => <reply> $who, Open VRML97 Toolkit and Browser. URL: http://www.vermontel.net/~cmorley/vrml.html
libwayne => <reply> $who, Abstract Data Types & Algorithms in C. URL: http://www.cs.toronto.edu/~wayne/libwayne/
libwiff => <reply> $who, Library for WIFF files. URL: http://www.fortunecity.com/rivendell/rings/814/libwiff.html
libwmf => <reply> $who, A library to convert microsoft's wmf file format to something useful. URL: http://www.csn.ul.ie/~caolan/docs/libwmf.html
view release on metacpan or search on metacpan
[INCOMPATBILE CHANGE]
- do not handle exception in Amon2::DBI, and use RaiseError.
0.08 2011-11-08
- fixed charset in 05_mysql.t utf8 subtest(makamaka)
0.07 2011-11-07
- added auto pg_enable_utf8 setting(makamaka)
- made dsn check case-insensitive(makamaka)
view release on metacpan or search on metacpan
lib/Amon2/Lite.pm view on Meta::CPAN
if ($router->method_not_allowed) {
my $content = '405 Method Not Allowed';
return $c->create_response(
405,
[
'Content-Type' => 'text/plain; charset=utf-8',
'Content-Length' => length($content),
],
[$content]
);
} else {
view release on metacpan or search on metacpan
lib/Amon2/Plugin/Web/MobileCharset.pm view on Meta::CPAN
sub init {
my ($class, $c, $conf) = @_;
Amon2::Util::add_method($c, 'html_content_type' => sub {
my $ma = shift->mobile_agent;
my $ct = $ma->is_docomo ? 'application/xhtml+xml;charset=' : 'text/html;charset=';
$ct .= $ma->can_display_utf8 ? 'utf-8' : 'Shift_JIS';
$ct;
});
Amon2::Util::add_method($c, 'encoding' => sub {
view release on metacpan or search on metacpan
script/amon2-xgettext.pl view on Meta::CPAN
"POT-Creation-Date: YEAR-MO-DA HO:MI+ZONE\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
POT
);
mkdir $po_dir;
view release on metacpan or search on metacpan
lib/Amon2/Plugin/Web/CpanelJSON.pm view on Meta::CPAN
my $res = $c->create_response($status);
my $encoding = $c->encoding();
$encoding = lc($encoding->mime_name) if ref $encoding;
$res->content_type("application/json; charset=$encoding");
$res->content_length(length($output));
$res->body($output);
if ($secure_headers) {
$secure_headers->apply($res->headers);
view release on metacpan or search on metacpan
lib/Amon2/Plugin/Web/JSON.pm view on Meta::CPAN
my $user_agent = $c->req->user_agent || '';
# defense from JSON hijacking
if ((!$c->request->header('X-Requested-With')) && $user_agent =~ /android/i && defined $c->req->header('Cookie') && ($c->req->method||'GET') eq 'GET') {
my $res = $c->create_response(403);
$res->content_type('text/html; charset=utf-8');
$res->content("Your request may be JSON hijacking.\nIf you are not an attacker, please add 'X-Requested-With' header to each request.");
$res->content_length(length $res->content);
return $res;
}
my $res = $c->create_response(200);
my $encoding = $c->encoding();
$encoding = lc($encoding->mime_name) if ref $encoding;
$res->content_type("application/json; charset=$encoding");
$res->header( 'X-Content-Type-Options' => 'nosniff' ); # defense from XSS
$res->content_length(length($output));
$res->body($output);
if (defined (my $status_code_field = $conf->{status_code_field})) {
view release on metacpan or search on metacpan
lib/AnnoCPAN/Control.pm view on Meta::CPAN
}
if ($template) {
my $default_vars = $self->default_vars;
$vars = { %$default_vars, %$vars };
print $self->header(
-charset => 'UTF-8',
-cookie => $self->cookies,
$type ? (-type => $type) : (),
);
$template .= '.html' unless $template =~ /\./;
my $output = '';
view release on metacpan or search on metacpan
lib/Any/Daemon/HTTP/Directory.pm view on Meta::CPAN
}
$self->{ADHD_loc} = $loc;
$self->{ADHD_fn} = $trans;
$self->{ADHD_dirlist} = $args->{directory_list} || 0;
$self->{ADHD_charset} = $args->{charset} || 'utf-8';
my $if = $args->{index_file};
my @if = ref $if eq 'ARRAY' ? @$if
: defined $if ? $if
: qw/index.html index.htm/;
lib/Any/Daemon/HTTP/Directory.pm view on Meta::CPAN
}
#-----------------
sub location() {shift->{ADHD_location}}
sub charset() {shift->{ADHD_charset}}
#-----------------
#-----------------------
lib/Any/Daemon/HTTP/Directory.pm view on Meta::CPAN
my $head = HTTP::Headers->new;
my $ct;
if(my $mime = $mimetypes->mimeTypeOf($fn))
{ $ct = $mime->type;
$ct .= '; charset='.$self->charset if $mime->isAscii;
}
else
{ $ct = 'binary/octet-stream';
}
lib/Any/Daemon/HTTP/Directory.pm view on Meta::CPAN
<p><i>Generated $now</i></p>
</body></html>
__PAGE
HTTP::Response->new(HTTP_OK, undef
, ['Content-Type' => 'text/html; charset='.$self->charset]
, $content
);
}
view release on metacpan or search on metacpan
lib/Any/Renderer/XML.pm view on Meta::CPAN
my ( $self, $data ) = @_;
TRACE ( "Rendering XML data" );
DUMP ( $data );
my $charset = $self->{options}{Encoding} || 'ISO-8859-1';
my %xmlopts = (
'noattr' => 1,
'keyattr' => undef,
'keeproot' => 1,
'rootname' => 'output',
'xmldecl' => qq{<?xml version="1.0" encoding="$charset" standalone="yes"?>},
'contentkey' => undef,
'noescape' => 0,
);
while ( my ( $k, $v ) = each %{ $self->{ 'options' }->{ 'XmlOptions' } } )
view release on metacpan or search on metacpan
lib/AnyEvent/FCGI/Request.pm view on Meta::CPAN
local %ENV = %{$request->params};
local $CGI::Q = new CGI::Stateless;
$request->respond(
'Hello, ' . (CGI::param('name') || 'anonymous'),
'Content-Type' => 'text/html; charset=utf8',
'Set-Cookie' => 'cookie_a=1; path=/',
'Set-Cookie' => 'cookie_b=2; path=/',
);
}
);
view release on metacpan or search on metacpan
lib/AnyEvent/HTTPD/ExtDirect.pm view on Meta::CPAN
$req->respond([
200,
'OK',
{
'Content-Type' => 'application/json; charset=utf-8',
'Content-Length' => $content_length,
},
$http_body,
]);
view release on metacpan or search on metacpan
lib/AnyEvent/Ident/Response.pm view on Meta::CPAN
}, $class;
if($list[0] eq 'USERID')
{
shift @list;
($self->{os}, $self->{charset}) = split /\s,\s*/, shift @list;
$self->{username} = shift @list;
$self->{charset} ||= 'US-ASCII';
}
else
{
shift @list;
$self->{error_type} = shift @list;
lib/AnyEvent/Ident/Response.pm view on Meta::CPAN
my $self = bless {
server_port => $args->{req}->server_port,
client_port => $args->{req}->client_port,
username => $args->{username},
os => $args->{os},
charset => $args->{charset},
error_type => $args->{error_type},
}, $class;
$self->{os} = 'OTHER' unless defined $self->{os};
if($self->{error_type})
{
$self->{raw} = join(':', join(',', $self->{server_port}, $self->{client_port}), 'ERROR', $self->{error_type});
}
elsif($self->{charset})
{
$self->{raw} = join(':', join(',', $self->{server_port}, $self->{client_port}), 'USERID', join(',', $self->{os}, $self->{charset}), $self->{username});
}
else
{
$self->{raw} = join(':', join(',', $self->{server_port}, $self->{client_port}), 'USERID', $self->{os}, $self->{username});
}
lib/AnyEvent/Ident/Response.pm view on Meta::CPAN
sub is_success { defined shift->{username} }
sub server_port { shift->{server_port} }
sub client_port { shift->{client_port} }
sub username { shift->{username} }
sub os { shift->{os} }
sub charset { shift->{charset} }
sub error_type { shift->{error_type} }
1;
__END__
lib/AnyEvent/Ident/Response.pm view on Meta::CPAN
my $os = $res->os
The operating system in the response.
=head2 charset
my $charset = $res->charset
The encoding for the username. This will be C<US-ASCII> if it
was not provided by the server.
=head2 error_type
view release on metacpan or search on metacpan
lib/AnyEvent/MSN.pm view on Meta::CPAN
$token =~ s/"/"/sg;
# Reply to good challenge. Expect no body.
$s->_soap_request(
'https://local-bay.contacts.msn.com/abservice/SharingService.asmx',
{ 'content-type' => 'text/xml; charset=utf-8',
SOAPAction =>
'"http://www.msn.com/webservices/AddressBook/FindMembership"'
},
sprintf(<<'XML', $token),
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
lib/AnyEvent/MSN.pm view on Meta::CPAN
#...
}
);
$s->_soap_request(
'https://local-bay.contacts.msn.com/abservice/abservice.asmx',
{ 'content-type' => 'text/xml; charset=utf-8',
SOAPAction =>
'"http://www.msn.com/webservices/AddressBook/ABFindContactsPaged"'
},
sprintf(<<'XML', $token),
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
lib/AnyEvent/MSN.pm view on Meta::CPAN
sub _soap_request {
my ($s, $uri, $headers, $content, $cb) = @_;
my %headers = (
'user-agent' => 'MSNPM 1.0',
'content-type' => 'application/soap+xml; charset=utf-8; action=""',
'Expect' => '100-continue',
'connection' => 'Keep-Alive'
);
#warn $content;
lib/AnyEvent/MSN.pm view on Meta::CPAN
# - I for Italics
#　- S for Strikethrough
# CO: Color (hex without #)
my $data
= sprintf
qq[Routing: 1.0\r\nTo: %s\r\nFrom: 1:%s;epid=%s\r\n\r\nReliability: 1.0\r\n\r\nMessaging: 2.0\r\nMessage-Type: Text\r\nContent-Type: text/plain; charset=UTF-8\r\nContent-Length: %d\r\nX-MMS-IM-Format: %s\r\n\r\n%s],
$to, $s->passport, $s->guid, length($msg), $format, $msg;
$s->send(qq'SDG 0 %d\r\n%s', length($data), $data);
}
sub nudge {
my ($s, $to) = @_;
$to = '1:' . $to if $to !~ m[^\d+:];
my $data
= sprintf
qq[Routing: 1.0\r\nTo: %s\r\nFrom: 1:%s;epid=%s\r\n\r\nReliability: 1.0\r\n\r\nMessaging: 2.0\r\nMessage-Type: Nudge\r\nService-Channel: IM/Online\r\nContent-Type: text/plain; charset=UTF-8\r\nContent-Length: 0\r\n\r\n],
$to, $s->passport, $s->guid;
$s->send("SDG 0 %d\r\n%s", length($data), $data);
}
sub add_contact {
lib/AnyEvent/MSN.pm view on Meta::CPAN
$token =~ s/"/"/sg;
#
$s->_soap_request(
'https://local-bay.contacts.msn.com/abservice/abservice.asmx',
{ 'content-type' => 'text/xml; charset=utf-8',
SOAPAction =>
'"http://www.msn.com/webservices/AddressBook/ABContactAdd"'
},
sprintf(<<'XML', $token, $contact),
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
lib/AnyEvent/MSN.pm view on Meta::CPAN
$token =~ s/"/"/sg;
#
$s->_soap_request(
'https://contacts.msn.com/abservice/abservice.asmx',
{'content-type' => 'text/xml; charset=utf-8',
SOAPAction =>
'"http://www.msn.com/webservices/AddressBook/ABContactDelete"'
},
sprintf(<<'XML', $token, $contact),
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
view release on metacpan or search on metacpan
lib/AnyEvent/MySQL/Imp.pm view on Meta::CPAN
=head2 recv_response($hd, %opt, $cb->(TYPE, data...))
RES_OK, $affected_rows, $insert_id, $server_status, $warning_count, $message
RES_ERROR, $errno, $sqlstate, $message
RES_RESULT, \@field, \@row
$field[$i] = [$catalog, $db, $table, $org_table, $name, $org_name, $charsetnr, $length, $type, $flags, $decimals, $default]
$row[$i] = [$field, $field, $field, ...]
RES_PREPARE, $stmt_id, \@param, \@column, $warning_count
$param[$i] = [$catalog, $db, $table, $org_table, $name, $org_name, $charsetnr, $length, $type, $flags, $decimals, $default]
$column[$i] = [$catalog, $db, $table, $org_table, $name, $org_name, $charsetnr, $length, $type, $flags, $decimals, $default]
opt:
prepare (set to truthy to recv prepare_ok)
=cut
sub recv_response {
my $cb = ref($_[-1]) eq 'CODE' ? pop : sub {};
lib/AnyEvent/MySQL/Imp.pm view on Meta::CPAN
CLIENT_MULTI_STATEMENTS | # Enable/disable multi-stmt support
CLIENT_MULTI_RESULTS | # Enable/disable multi-results
0
), 4); # client_flags
put_num($packet, 0x1000000, 4); # max_packet_size
put_num($packet, $server_lang, 1); # charset_number
$packet .= "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; # filler
put_zstr($packet, $username); # username
if( $password eq '' ) {
put_lcs($packet, '');
}
view release on metacpan or search on metacpan
lib/AnyEvent/Net/Curl/Queued/Easy.pm view on Meta::CPAN
my $is_json = 0;
($val, $is_json) = $self->_setopt_postfields($val);
$orig->($self =>
Net::Curl::Easy::CURLOPT_HTTPHEADER,
[ 'Content-Type: application/json; charset=utf-8' ],
) if $is_json;
} elsif ($key == Net::Curl::Easy::CURLOPT_ENCODING) {
$self->_autodecoded(1);
$val = $self->_setopt_encoding($val);
}
lib/AnyEvent/Net/Curl/Queued/Easy.pm view on Meta::CPAN
);
Complete list of options: L<http://curl.haxx.se/libcurl/c/curl_easy_setopt.html>
If C<CURLOPT_POSTFIELDS> is a C<HashRef> or looks like a valid JSON (validates via L<JSON>),
it is encoded as UTF-8 and C<Content-Type: application/json; charset=utf-8> header is set automatically.
=head2 getinfo(VAR_NAME [, VAR_NAME])
Extends L<Net::Curl::Easy> C<getinfo()> so it is able to get several variables at once;
C<HashRef> parameter under void context will fill respective values in the C<HashRef>:
view release on metacpan or search on metacpan
lib/AnyEvent/RPC/Enc.pm view on Meta::CPAN
}
sub decode_response {
my $self = shift;
my $res = shift; # don't decode
return $res->decoded_content( charset => 'none' );
}
sub decode {
my $self = shift;
my $rpc = shift;
view release on metacpan or search on metacpan
lib/AnyEvent/Riak/PBC.pm view on Meta::CPAN
'content_type', 2, undef
],
[
Google::ProtocolBuffers::Constants::LABEL_OPTIONAL(),
Google::ProtocolBuffers::Constants::TYPE_BYTES(),
'charset', 3, undef
],
[
Google::ProtocolBuffers::Constants::LABEL_OPTIONAL(),
Google::ProtocolBuffers::Constants::TYPE_BYTES(),
'content_encoding', 4, undef
view release on metacpan or search on metacpan
lib/AnyEvent/SparkBot/SharedRole.pm view on Meta::CPAN
sub default_headers {
my ($self)=@_;
my $h=new HTTP::Headers;
$h->header(Authorization=>'Bearer ' .$self->token);
$h->header('Content-Type', 'application/json; charset=UTF-8');
return $h;
}
=back
view release on metacpan or search on metacpan
WebDriver.pm view on Meta::CPAN
AnyEvent::HTTP::http_request $method => "$self->{_ep}$ep",
body => $body,
$self->{persistent} ? (persistent => 1) : (),
$self->{proxy} eq "default" ? () : (proxy => $self->{proxy}),
timeout => $self->{timeout},
headers => { "content-type" => "application/json; charset=utf-8", "cache-control" => "no-cache" },
sub {
my ($res, $hdr) = @_;
$res = eval { $json->decode ($res) };
$hdr->{Status} = 500 unless exists $res->{value};
view release on metacpan or search on metacpan
xt/js/browser.html view on Meta::CPAN
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>AnyEvent::WebSocket::Server</title>
<link rel="stylesheet" href="http://code.jquery.com/qunit/qunit-1.12.0.css">
</head>
<body>
<div id="qunit"></div>
view release on metacpan or search on metacpan
lib/AnyEvent/Intro.pod view on Meta::CPAN
Escape character is '^]'.
GET /test HTTP/1.0
HTTP/1.0 404 Not Found
Date: Mon, 02 Jun 2008 07:05:54 GMT
Content-Type: text/html; charset=UTF-8
<html><head>
[...]
Connection closed by foreign host.
view release on metacpan or search on metacpan
lib/Aozora2Epub/CachedGet.pm view on Meta::CPAN
my $content_type = $r->{headers}{'content-type'};
unless ($content_type =~ m{text/}) {
$CACHE->set($url, $content);
return $content; # binary
}
if ($content_type =~ /charset=([^;]+)/) {
$encoding = $1;
} elsif ($content =~ m{<meta http-equiv="content-type" content="[^"]+;charset=(\w+)"}i) {
$encoding = $1;
}
$content = Encode::decode($encoding, $content);
$CACHE->set($url, $content);
return $content;
view release on metacpan or search on metacpan
This member when set appends itself to the value of the Content-Type
HTTP header. If $Response->{Charset} = 'ISO-LATIN-1' is set, the
corresponding header would look like:
Content-Type: text/html; charset=ISO-LATIN-1
=item $Response->{Clean} = 0-9;
API extension. Set the Clean level, default 0, on a per script basis.
Clean of 1-9 compresses text/html output. Please see
+ XMLSubs tags with "-" in them will have "-" replaced with "_" or underscore, so a
tag like <my:render-table /> will be translated to &my::render_table() ... tags with
- in them are common in extended XML syntaxes, but perl subs cannot have - in them only.
+ Clean setting now works on output when $Response->{ContentType} begins with text/html;
like "text/html; charset=iso-8859-2" ... before Clean would only work on output marked
with ContentType text/html. Thanks to Szymon Juraszczyk for recommending fix.
--Fixed a bug which would cause Session_OnEnd to be called twice on sessions in a certain case,
particularly when an old expired session gets reused by and web browser... this bug was
a result of a incomplete session cleanup method in this case. Thanks to Oleg Kobyakovskiy