PaxHeader/+CONTENTS000644 000000 000000 00000000025 15213024447 014360 xustar00rootwheel000000 000000 21 hdrcharset=BINARY +CONTENTS000644 000000 000000 00000005353 15213024447 012420 0ustar00rootwheel000000 000000 @cwd /usr/pkg @pkgcfl p5-libwww<6.00 @name p5-HTTP-Message-7.02 @blddep p5-Clone-0.50 @pkgdep p5-Clone>=0.46 @blddep p5-URI-5.34 @pkgdep p5-URI-[0-9]* @blddep p5-HTTP-Date-6.06nb2 @pkgdep p5-HTTP-Date>=6 @blddep p5-Encode-Locale-1.05nb11 @pkgdep p5-Encode-Locale>=1.02 @blddep p5-LWP-MediaTypes-6.04nb6 @pkgdep p5-LWP-MediaTypes>=6.01 @blddep p5-IO-HTML-1.004nb5 @pkgdep p5-IO-HTML-[0-9]* @blddep perl-5.42.2nb2 @pkgdep perl>=5.42.0<5.43.0 @blddep digest-20220214 @blddep mktools-20250213 @blddep cwrappers-20220403 @comment The following lines are automatically generated @comment from the installed .packlist files. lib/perl5/vendor_perl/5.42.0/HTTP/Config.pm @comment MD5:1aee832bb3ab8b276ce16af38024690b lib/perl5/vendor_perl/5.42.0/HTTP/Headers.pm @comment MD5:2ecf19b58da0bfa32f6a660d21a9714c lib/perl5/vendor_perl/5.42.0/HTTP/Headers/Auth.pm @comment MD5:545d23562962e6565a2b26c9680e87e4 lib/perl5/vendor_perl/5.42.0/HTTP/Headers/ETag.pm @comment MD5:57a163680fa8887927be9a78abc7cee0 lib/perl5/vendor_perl/5.42.0/HTTP/Headers/Util.pm @comment MD5:4344127f22c012adc889b55b3cb14f99 lib/perl5/vendor_perl/5.42.0/HTTP/Message.pm @comment MD5:0438ade81ecfaef3e3e0c867437e68da lib/perl5/vendor_perl/5.42.0/HTTP/Request.pm @comment MD5:bc63a8fd3bdab89d5fc701d8e21a9895 lib/perl5/vendor_perl/5.42.0/HTTP/Request/Common.pm @comment MD5:74143885ff23665f9644ccad344b0a5d lib/perl5/vendor_perl/5.42.0/HTTP/Response.pm @comment MD5:14c52d3ebc72dcd9715111a680e0654e lib/perl5/vendor_perl/5.42.0/HTTP/Status.pm @comment MD5:89653ef889549bf6eff502f99b260a73 lib/perl5/vendor_perl/5.42.0/powerpc-netbsd-thread-multi/auto/HTTP/Message/.packlist @comment MD5:c346fd17a7211178aef6d4eac60d9bc7 lib/perl5/vendor_perl/man/man3/HTTP::Config.3 @comment MD5:965cd7169629849a5dac8060698a66ee lib/perl5/vendor_perl/man/man3/HTTP::Headers.3 @comment MD5:da41bc858b32493af4d0a301a3f72a8f lib/perl5/vendor_perl/man/man3/HTTP::Headers::Auth.3 @comment MD5:fc35c9e8d8bc7e7c9d44f0e293af48ee lib/perl5/vendor_perl/man/man3/HTTP::Headers::ETag.3 @comment MD5:62c07454995796d1216b8a08b9fd846e lib/perl5/vendor_perl/man/man3/HTTP::Headers::Util.3 @comment MD5:486e91d4e0ef7c09f8a96fadbebca110 lib/perl5/vendor_perl/man/man3/HTTP::Message.3 @comment MD5:193cb45e964eec41d2b01ecdb3529766 lib/perl5/vendor_perl/man/man3/HTTP::Request.3 @comment MD5:7bc176c802675e9c2f343380a14df72f lib/perl5/vendor_perl/man/man3/HTTP::Request::Common.3 @comment MD5:888d0fdeaf605b3a3f30d1bcd3f1117a lib/perl5/vendor_perl/man/man3/HTTP::Response.3 @comment MD5:9668ace93e583e2c910a91f1f37cae7d lib/perl5/vendor_perl/man/man3/HTTP::Status.3 @comment MD5:0df098c5fdca00dac399f571e5bed323 @cwd /usr/pkg @ignore +COMMENT @ignore +DESC @ignore +INSTALL @ignore +DEINSTALL @ignore +BUILD_VERSION @ignore +BUILD_INFO @ignore +SIZE_PKG @ignore +SIZE_ALL PaxHeader/+COMMENT000444 000000 000000 00000000025 15213024447 014223 xustar00rootwheel000000 000000 21 hdrcharset=BINARY +COMMENT000444 000000 000000 00000000036 15213024447 012254 0ustar00rootwheel000000 000000 Construct HTTP style messages PaxHeader/+DESC000444 000000 000000 00000000025 15213024447 013637 xustar00rootwheel000000 000000 21 hdrcharset=BINARY +DESC000444 000000 000000 00000000162 15213024447 011670 0ustar00rootwheel000000 000000 perl5 module HTTP::Message - HTTP style message (base class) Homepage: https://metacpan.org/release/HTTP-Message PaxHeader/+INSTALL000755 000000 000000 00000000025 15213024441 014226 xustar00rootwheel000000 000000 21 hdrcharset=BINARY +INSTALL000755 000000 000000 00000007312 15213024441 012263 0ustar00rootwheel000000 000000 #!/bin/sh # # $NetBSD: header,v 1.3 2014/12/30 15:13:20 wiz Exp $ SELF="$0" PKGNAME="$1" STAGE="$2" shift 2 AWK="/usr/bin/awk" BASENAME="/usr/bin/basename" CAT="/bin/cat" CHGRP="/usr/bin/chgrp" CHMOD="/bin/chmod" CHOWN="/usr/sbin/chown" CMP="/usr/bin/cmp" CP="/bin/cp" DIRNAME="/usr/bin/dirname" ECHO="echo" ECHO_N="echo -n" EGREP="/usr/bin/egrep" EXPR="/bin/expr" FALSE="false" FIND="/usr/bin/find" GREP="/usr/bin/grep" GTAR="" HEAD="/usr/bin/head" ID="/usr/bin/id" LINKFARM="/usr/pkg/sbin/linkfarm" LN="/bin/ln" LS="/bin/ls" MKDIR="/bin/mkdir -p" MV="mv -f" PERL5="/usr/pkg/bin/perl" PKG_ADMIN="/usr/pkg/sbin/pkg_admin" PKG_INFO="/usr/pkg/sbin/pkg_info" PWD_CMD="/bin/pwd" RM="/bin/rm" RMDIR="/bin/rmdir" SED="/usr/bin/sed" SETENV="/usr/bin/env" SH="/bin/sh" SORT="/usr/bin/sort" SU="/usr/bin/su" TEST="test" TOUCH="/usr/bin/touch" TR="/usr/bin/tr" TRUE="true" XARGS="/usr/bin/xargs" CURDIR=`${PWD_CMD}` : ${PKG_METADATA_DIR=${CURDIR}} PKGBASE="p5-HTTP-Message" LOCALBASE="/usr/pkg" X11BASE="/usr/X11R7" PREFIX="/usr/pkg" PKG_SYSCONFBASE="/usr/pkg/etc" PKG_SYSCONFBASEDIR="/usr/pkg/etc" PKG_SYSCONFDIR="/usr/pkg/etc" CONF_DEPENDS="" CONF_IGNORE_FILES="*[~#] *.OLD *.orig *,v .pkgsrc */.pkgsrc" case "${PKG_CONFIG:-YES}" in [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1) _PKG_CONFIG=yes ;; [Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|[Oo][Ff][Ff]|0) _PKG_CONFIG=yes ;; esac # $NetBSD: install,v 1.5 2017/06/14 16:23:09 prlw1 Exp $ case ${STAGE} in PRE-INSTALL) # # Unpack the helper scriptlets. # ${SH} ${SELF} ${PKGNAME} UNPACK # # Require that necessary users and groups exist or else fail the # installation of the package. # ${TEST} ! -x ./+USERGROUP || { ./+USERGROUP ADD ${PKG_METADATA_DIR} if ./+USERGROUP CHECK-ADD ${PKG_METADATA_DIR}; then : else exit 1 fi; } ${TEST} ! -x ./+DIRS || ./+DIRS ADD ${PKG_METADATA_DIR} ${TEST} ! -x ./+DIRS || ./+DIRS PERMS ${PKG_METADATA_DIR} ;; POST-INSTALL) # # Rebuild the system run-time library search path database. # ${TEST} ! -x ./+SHLIBS || ./+SHLIBS ADD ${PKG_METADATA_DIR} # # Copy configuration/support files into place. # ${TEST} ! -x ./+FILES || ./+FILES ADD ${PKG_METADATA_DIR} ${TEST} ! -x ./+FILES || ./+FILES PERMS ${PKG_METADATA_DIR} # # Set special permissions on any files/directories that need them. # ${TEST} ! -x ./+PERMS || ./+PERMS ${PKG_METADATA_DIR} # # Update any fonts databases. # ${TEST} ! -x ./+FONTS || ./+FONTS ${PKG_METADATA_DIR} # # Update any icon theme caches. # ${TEST} ! -x ./+ICON_THEMES || ./+ICON_THEMES UPDATE ${PKG_METADATA_DIR} # Check for any missing bits after we're finished installing. # ${TEST} ! -x ./+DIRS || ./+DIRS CHECK-ADD ${PKG_METADATA_DIR} ${TEST} ! -x ./+DIRS || ./+DIRS CHECK-PERMS ${PKG_METADATA_DIR} ${TEST} ! -x ./+FILES || ./+FILES CHECK-ADD ${PKG_METADATA_DIR} ${TEST} ! -x ./+FILES || ./+FILES CHECK-PERMS ${PKG_METADATA_DIR} # # Register shells in /etc/shells. # ${TEST} ! -x ./+SHELL || ./+SHELL ADD ${PKG_METADATA_DIR} ${TEST} ! -x ./+SHELL || ./+SHELL CHECK-ADD ${PKG_METADATA_DIR} # # Register info files. # ${TEST} ! -x ./+INFO_FILES || ./+INFO_FILES ADD ${PKG_METADATA_DIR} # # Register package into ocaml-findlib. # ${TEST} ! -x ./+OCAML_FINDLIB_REGISTER || ./+OCAML_FINDLIB_REGISTER ADD ${PKG_METADATA_DIR} ;; esac # $NetBSD: install.tmpl,v 1.2 2005/08/12 19:59:03 jlam Exp $ case ${STAGE} in POST-INSTALL) eval `${PERL5} -V:scriptdir` PERL5_PACKLIST="/usr/pkg/lib/perl5/vendor_perl/5.42.0/powerpc-netbsd-thread-multi/auto/HTTP/Message/.packlist" # Symlink the bits that belong to this module. $scriptdir/perllink -f -p ${PKG_PREFIX} add ${PERL5_PACKLIST} ;; esac # $NetBSD: footer,v 1.1 2006/05/21 23:50:15 jlam Exp $ exit 0 PaxHeader/+DEINSTALL000755 000000 000000 00000000025 15213024441 014437 xustar00rootwheel000000 000000 21 hdrcharset=BINARY +DEINSTALL000755 000000 000000 00000007353 15213024441 012501 0ustar00rootwheel000000 000000 #!/bin/sh # # $NetBSD: header,v 1.3 2014/12/30 15:13:20 wiz Exp $ SELF="$0" PKGNAME="$1" STAGE="$2" shift 2 AWK="/usr/bin/awk" BASENAME="/usr/bin/basename" CAT="/bin/cat" CHGRP="/usr/bin/chgrp" CHMOD="/bin/chmod" CHOWN="/usr/sbin/chown" CMP="/usr/bin/cmp" CP="/bin/cp" DIRNAME="/usr/bin/dirname" ECHO="echo" ECHO_N="echo -n" EGREP="/usr/bin/egrep" EXPR="/bin/expr" FALSE="false" FIND="/usr/bin/find" GREP="/usr/bin/grep" GTAR="" HEAD="/usr/bin/head" ID="/usr/bin/id" LINKFARM="/usr/pkg/sbin/linkfarm" LN="/bin/ln" LS="/bin/ls" MKDIR="/bin/mkdir -p" MV="mv -f" PERL5="/usr/pkg/bin/perl" PKG_ADMIN="/usr/pkg/sbin/pkg_admin" PKG_INFO="/usr/pkg/sbin/pkg_info" PWD_CMD="/bin/pwd" RM="/bin/rm" RMDIR="/bin/rmdir" SED="/usr/bin/sed" SETENV="/usr/bin/env" SH="/bin/sh" SORT="/usr/bin/sort" SU="/usr/bin/su" TEST="test" TOUCH="/usr/bin/touch" TR="/usr/bin/tr" TRUE="true" XARGS="/usr/bin/xargs" CURDIR=`${PWD_CMD}` : ${PKG_METADATA_DIR=${CURDIR}} PKGBASE="p5-HTTP-Message" LOCALBASE="/usr/pkg" X11BASE="/usr/X11R7" PREFIX="/usr/pkg" PKG_SYSCONFBASE="/usr/pkg/etc" PKG_SYSCONFBASEDIR="/usr/pkg/etc" PKG_SYSCONFDIR="/usr/pkg/etc" CONF_DEPENDS="" CONF_IGNORE_FILES="*[~#] *.OLD *.orig *,v .pkgsrc */.pkgsrc" case "${PKG_CONFIG:-YES}" in [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1) _PKG_CONFIG=yes ;; [Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|[Oo][Ff][Ff]|0) _PKG_CONFIG=yes ;; esac # $NetBSD: deinstall.tmpl,v 1.3 2010/02/14 15:10:38 tron Exp $ case ${STAGE} in DEINSTALL) eval `${PERL5} -V:prefix -V:archlib -V:scriptdir` PERL5_PACKLIST="/usr/pkg/lib/perl5/vendor_perl/5.42.0/powerpc-netbsd-thread-multi/auto/HTTP/Message/.packlist" # Remove the perllocal.pod file. case "$archlib" in $prefix/*) archlib="${PKG_PREFIX-/usr/pkg}/${archlib#$prefix/}" ;; esac ${RM} -f $archlib/perllocal.pod ${RMDIR} -p $archlib 2>/dev/null || ${TRUE} # Remove any symlinked bits that belong to this module. $scriptdir/perllink -f -p ${PKG_PREFIX-/usr/pkg} delete ${PERL5_PACKLIST} # If this is not the perl package, then re-link any perl bits # back into place. # $scriptdir/perllink -p ${PKG_PREFIX-/usr/pkg} add ;; esac # $NetBSD: deinstall,v 1.5 2017/06/14 16:23:09 prlw1 Exp $ case ${STAGE} in DEINSTALL) # # Unregister package from ocaml-findlib. # ${TEST} ! -x ./+OCAML_FINDLIB_REGISTER || ./+OCAML_FINDLIB_REGISTER REMOVE ${OCAML_FINDLIB_DIR} # # Unregister info files. # ${TEST} ! -x ./+INFO_FILES || ./+INFO_FILES REMOVE ${PKG_METADATA_DIR} # # Remove any icon theme caches. # ${TEST} ! -x ./+ICON_THEMES || ./+ICON_THEMES REMOVE ${PKG_METADATA_DIR} # # Remove shells from /etc/shells. # ${TEST} ! -x ./+SHELL || ./+SHELL REMOVE ${PKG_METADATA_DIR} ${TEST} ! -x ./+SHELL || ./+SHELL CHECK-REMOVE ${PKG_METADATA_DIR} # Remove configuration files if they don't differ from the default # config file. # ${TEST} ! -x ./+FILES || ./+FILES REMOVE ${PKG_METADATA_DIR} ;; POST-DEINSTALL) # # Update any fonts databases. # ${TEST} ! -x ./+FONTS || ./+FONTS ${PKG_METADATA_DIR} # # Update any icon theme caches. # ${TEST} ! -x ./+ICON_THEMES || ./+ICON_THEMES UPDATE ${PKG_METADATA_DIR} # # Rebuild the system run-time library search path database. # ${TEST} ! -x ./+SHLIBS || ./+SHLIBS REMOVE ${PKG_METADATA_DIR} # # Remove empty directories and unused users/groups. # ${TEST} ! -x ./+DIRS || ./+DIRS REMOVE ${PKG_METADATA_DIR} ${TEST} ! -x ./+USERGROUP || ./+USERGROUP REMOVE ${PKG_METADATA_DIR} # # Check for any existing bits after we're finished de-installing. # ${TEST} ! -x ./+USERGROUP || ./+USERGROUP CHECK-REMOVE ${PKG_METADATA_DIR} ${TEST} ! -x ./+FILES || ./+FILES CHECK-REMOVE ${PKG_METADATA_DIR} ${TEST} ! -x ./+DIRS || ./+DIRS CHECK-REMOVE ${PKG_METADATA_DIR} ;; esac # $NetBSD: footer,v 1.1 2006/05/21 23:50:15 jlam Exp $ exit 0 PaxHeader/+BUILD_VERSION000644 000000 000000 00000000025 15213024445 015165 xustar00rootwheel000000 000000 21 hdrcharset=BINARY +BUILD_VERSION000644 000000 000000 00000000432 15213024445 013216 0ustar00rootwheel000000 000000 www/p5-HTTP-Message/DESCR: 765ca799759318adcf179cf348afe07e19dbfbfc24dc84d5b324acb9d0bf1f08 www/p5-HTTP-Message/Makefile: aa0475c03c2b6b37d5528ca0de53d2efcfc03b262acba3ba9415a655ae5dc40a www/p5-HTTP-Message/distinfo: 7c1ae93f6b77c8563bba1a909d9dc7c9be1da3e2b92ce7d66b99457020ea86c8 PaxHeader/+BUILD_INFO000644 000000 000000 00000000025 15213024444 014572 xustar00rootwheel000000 000000 21 hdrcharset=BINARY +BUILD_INFO000644 000000 000000 00000006145 15213024444 012632 0ustar00rootwheel000000 000000 ABI= BUILD_DATE=2026-06-13 00:43:32 +0900 BUILD_HOST=NetBSD wiiu 11.99.5 NetBSD 11.99.5 (NINTENDO.MP) #0: Mon Mar 2 13:41:54 UTC 2026 mkrepro@mkrepro.NetBSD.org:/usr/src/sys/arch/evbppc/compile/NINTENDO.MP evbppc CATEGORIES=www perl5 CC_VERSION=gcc-14.3.0 CFLAGS=-O2 -I/usr/pkg/include -I/usr/include CMAKE_CONFIGURE_ARGS= CONFIGURE_ARGS= CONFIGURE_ENV=PTHREAD_CFLAGS=\ -pthread\ PTHREAD_LDFLAGS=\ -pthread PTHREAD_LIBS= PTHREADBASE=/usr INSTALL_INFO= MAKEINFO=/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.tools/bin/makeinfo FLEX= BISON= ITSTOOL=/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.tools/bin/itstool GDBUS_CODEGEN=/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.tools/bin/gdbus-codegen PKG_CONFIG=/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.tools/bin/pkg-config PKG_CONFIG_LIBDIR=/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.buildlink/lib/pkgconfig:/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.buildlink/share/pkgconfig PKG_CONFIG_LOG=/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.pkg-config.log PKG_CONFIG_PATH= MAKE=make CWRAPPERS_CONFIG_DIR=/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.cwrapper/config CXXCPP=cpp CC=gcc CFLAGS=-O2\ -I/usr/pkg/include\ -I/usr/include CPPFLAGS=-I/usr/pkg/include\ -I/usr/include CXX=c++ CXXFLAGS=-O2\ -I/usr/pkg/include\ -I/usr/include COMPILER_RPATH_FLAG=-Wl,-R F77=gfortran FC=gfortran FFLAGS=-O LANG=C LC_ALL=C LC_COLLATE=C LC_CTYPE=C LC_MESSAGES=C LC_MONETARY=C LC_NUMERIC=C LC_TIME=C LDFLAGS=-Wl,-zrelro\ -L/usr/pkg/lib\ -Wl,-R/usr/pkg/lib/perl5/5.42.0/powerpc-netbsd-thread-multi/CORE\ -L/usr/lib\ -Wl,-R/usr/lib\ -Wl,-R/usr/pkg/lib LINKER_RPATH_FLAG=-R PATH=/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.cwrapper/bin:/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.buildlink/bin:/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.tools/bin:/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.gcc/bin:/usr/pkg/bin:/home/jun/bin:/bin:/sbin:/usr/bin:/usr/sbin:/usr/X11R7/bin:/usr/pkg/bin:/usr/pkg/sbin:/usr/games:/usr/local/bin:/usr/local/sbin:/usr/sbin:/usr/bin:/usr/pkg/bin:/usr/X11R7/bin PREFIX=/usr/pkg MAKELEVEL=0 CONFIG_SITE= ftp_proxy=downloads-forbidden-except-during-fetch http_proxy=downloads-forbidden-except-during-fetch https_proxy=downloads-forbidden-except-during-fetch no_proxy= PKG_SYSCONFDIR=/usr/pkg/etc HOME=/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.home CWRAPPERS_CONFIG_DIR=/usr/pkgsrc/www/p5-HTTP-Message/work.powerpc/.cwrapper/config CPE_URI=cpe:2.3:a:p5-HTTP-Message:p5-HTTP-Message:7.02:::::netbsd11:powerpc CPPFLAGS= -I/usr/pkg/include -I/usr/include FFLAGS=-O HOMEPAGE=https://metacpan.org/release/HTTP-Message LDFLAGS= -Wl,-zrelro -L/usr/pkg/lib -Wl,-R/usr/pkg/lib/perl5/5.42.0/powerpc-netbsd-thread-multi/CORE -L/usr/lib -Wl,-R/usr/lib -Wl,-R/usr/pkg/lib LICENSE=gnu-gpl-v2 OR artistic LOCALBASE=/usr/pkg MACHINE_ARCH=powerpc MACHINE_GNU_ARCH=powerpc MAINTAINER=pkgsrc-users@NetBSD.org NO_BIN_ON_CDROM= NO_BIN_ON_FTP= NO_SRC_ON_CDROM= NO_SRC_ON_FTP= OBJECT_FMT=ELF OPSYS=NetBSD OS_VERSION=11.99.5 PKGGNUDIR=gnu/ PKGINFODIR=info PKGMANDIR=man PKGPATH=www/p5-HTTP-Message PKGTOOLS_VERSION=20091115 PKG_SYSCONFBASEDIR=/usr/pkg/etc PKG_SYSCONFDIR=/usr/pkg/etc RESTRICTED= _USE_DESTDIR=user-destdir PaxHeader/+SIZE_PKG000644 000000 000000 00000000025 15213024445 014374 xustar00rootwheel000000 000000 21 hdrcharset=BINARY +SIZE_PKG000644 000000 000000 00000000007 15213024445 012423 0ustar00rootwheel000000 000000 245894 PaxHeader/+SIZE_ALL000644 000000 000000 00000000025 15213024445 014363 xustar00rootwheel000000 000000 21 hdrcharset=BINARY +SIZE_ALL000644 000000 000000 00000000011 15213024445 012405 0ustar00rootwheel000000 000000 79059519 lib/perl5/vendor_perl/5.42.0/HTTP/PaxHeader/Config.pm000444 000000 000000 00000000025 15210655656 022320 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/HTTP/Config.pm000444 000000 000000 00000027045 15210655656 020362 0ustar00rootwheel000000 000000 package HTTP::Config; use strict; use warnings; our $VERSION = '7.02'; use URI; sub new { my $class = shift; return bless [], $class; } sub entries { my $self = shift; @$self; } sub empty { my $self = shift; not @$self; } sub add { if (@_ == 2) { my $self = shift; push(@$self, shift); return; } my($self, %spec) = @_; push(@$self, \%spec); return; } sub find2 { my($self, %spec) = @_; my @found; my @rest; ITEM: for my $item (@$self) { for my $k (keys %spec) { no warnings 'uninitialized'; if (!exists $item->{$k} || $spec{$k} ne $item->{$k}) { push(@rest, $item); next ITEM; } } push(@found, $item); } return \@found unless wantarray; return \@found, \@rest; } sub find { my $self = shift; my $f = $self->find2(@_); return @$f if wantarray; return $f->[0]; } sub remove { my($self, %spec) = @_; my($removed, $rest) = $self->find2(%spec); @$self = @$rest if @$removed; return @$removed; } my %MATCH = ( m_scheme => sub { my($v, $uri) = @_; return $uri->_scheme eq $v; # URI known to be canonical }, m_secure => sub { my($v, $uri) = @_; my $secure = $uri->can("secure") ? $uri->secure : $uri->_scheme eq "https"; return $secure == !!$v; }, m_host_port => sub { my($v, $uri) = @_; return unless $uri->can("host_port"); return $uri->host_port eq $v, 7; }, m_host => sub { my($v, $uri) = @_; return unless $uri->can("host"); return $uri->host eq $v, 6; }, m_port => sub { my($v, $uri) = @_; return unless $uri->can("port"); return $uri->port eq $v; }, m_domain => sub { my($v, $uri) = @_; return unless $uri->can("host"); my $h = $uri->host; $h = "$h.local" unless $h =~ /\./; $v = ".$v" unless $v =~ /^\./; return length($v), 5 if substr($h, -length($v)) eq $v; return 0; }, m_path => sub { my($v, $uri) = @_; return unless $uri->can("path"); return $uri->path eq $v, 4; }, m_path_prefix => sub { my($v, $uri) = @_; return unless $uri->can("path"); my $path = $uri->path; my $len = length($v); return $len, 3 if $path eq $v; return 0 if length($path) <= $len; $v .= "/" unless $v =~ m,/\z,,; return $len, 3 if substr($path, 0, length($v)) eq $v; return 0; }, m_path_match => sub { my($v, $uri) = @_; return unless $uri->can("path"); return $uri->path =~ $v; }, m_uri__ => sub { my($v, $k, $uri) = @_; return unless $uri->can($k); return 1 unless defined $v; return $uri->$k eq $v; }, m_method => sub { my($v, $uri, $request) = @_; return $request && $request->method eq $v; }, m_proxy => sub { my($v, $uri, $request) = @_; return $request && ($request->{proxy} || "") eq $v; }, m_code => sub { my($v, $uri, $request, $response) = @_; $v =~ s/xx\z//; return unless $response; return length($v), 2 if substr($response->code, 0, length($v)) eq $v; }, m_media_type => sub { # for request too?? my($v, $uri, $request, $response) = @_; return unless $response; return 1, 1 if $v eq "*/*"; my $ct = $response->content_type; return 2, 1 if $v =~ s,/\*\z,, && $ct =~ m,^\Q$v\E/,; return 3, 1 if $v eq "html" && $response->content_is_html; return 4, 1 if $v eq "xhtml" && $response->content_is_xhtml; return 10, 1 if $v eq $ct; return 0; }, m_header__ => sub { my($v, $k, $uri, $request, $response) = @_; return unless $request; my $req_header = $request->header($k); return 1 if defined($req_header) && $req_header eq $v; if ($response) { my $res_header = $response->header($k); return 1 if defined($res_header) && $res_header eq $v; } return 0; }, m_response_attr__ => sub { my($v, $k, $uri, $request, $response) = @_; return unless $response; return 1 if !defined($v) && exists $response->{$k}; return 0 unless exists $response->{$k}; return 1 if $response->{$k} eq $v; return 0; }, ); sub matching { my $self = shift; if (@_ == 1) { if ($_[0]->can("request")) { unshift(@_, $_[0]->request); unshift(@_, undef) unless defined $_[0]; } unshift(@_, $_[0]->uri_canonical) if $_[0] && $_[0]->can("uri_canonical"); } my($uri, $request, $response) = @_; $uri = URI->new($uri) unless ref($uri); my @m; ITEM: for my $item (@$self) { my $order; for my $ikey (keys %$item) { my $mkey = $ikey; my $k; $k = $1 if $mkey =~ s/__(.*)/__/; if (my $m = $MATCH{$mkey}) { #print "$ikey $mkey\n"; my($c, $o); my @arg = ( defined($k) ? $k : (), $uri, $request, $response ); my $v = $item->{$ikey}; $v = [$v] unless ref($v) eq "ARRAY"; for (@$v) { ($c, $o) = $m->($_, @arg); #print " - $_ ==> $c $o\n"; last if $c; } next ITEM unless $c; $order->[$o || 0] += $c; } } $order->[7] ||= 0; $item->{_order} = join(".", reverse map sprintf("%03d", $_ || 0), @$order); push(@m, $item); } @m = sort { $b->{_order} cmp $a->{_order} } @m; delete $_->{_order} for @m; return @m if wantarray; return $m[0]; } sub add_item { my $self = shift; my $item = shift; return $self->add(item => $item, @_); } sub remove_items { my $self = shift; return map $_->{item}, $self->remove(@_); } sub matching_items { my $self = shift; return map $_->{item}, $self->matching(@_); } 1; =pod =encoding UTF-8 =head1 NAME HTTP::Config - Configuration for request and response objects =head1 VERSION version 7.02 =head1 SYNOPSIS use HTTP::Config; my $c = HTTP::Config->new; $c->add(m_domain => ".example.com", m_scheme => "http", verbose => 1); use HTTP::Request; my $request = HTTP::Request->new(GET => "http://www.example.com"); if (my @m = $c->matching($request)) { print "Yadayada\n" if $m[0]->{verbose}; } =head1 DESCRIPTION An C object is a list of entries that can be matched against request or request/response pairs. Its purpose is to hold configuration data that can be looked up given a request or response object. Each configuration entry is a hash. Some keys specify matching to occur against attributes of request/response objects. Other keys can be used to hold user data. The following methods are provided: =over 4 =item $conf = HTTP::Config->new Constructs a new empty C object and returns it. =item $conf->entries Returns the list of entries in the configuration object. In scalar context returns the number of entries. =item $conf->empty Return true if there are no entries in the configuration object. This is just a shorthand for C<< not $conf->entries >>. =item $conf->add( %matchspec, %other ) =item $conf->add( \%entry ) Adds a new entry to the configuration. You can either pass separate key/value pairs or a hash reference. =item $conf->remove( %spec ) Removes (and returns) the entries that have matches for all the key/value pairs in %spec. If %spec is empty this will match all entries; so it will empty the configuration object. =item $conf->matching( $uri, $request, $response ) =item $conf->matching( $uri ) =item $conf->matching( $request ) =item $conf->matching( $response ) Returns the entries that match the given $uri, $request and $response triplet. If called with a single $request object then the $uri is obtained by calling its 'uri_canonical' method. If called with a single $response object, then the request object is obtained by calling its 'request' method; and then the $uri is obtained as if a single $request was provided. The entries are returned with the most specific matches first. In scalar context returns the most specific match or C in none match. =item $conf->add_item( $item, %matchspec ) =item $conf->remove_items( %spec ) =item $conf->matching_items( $uri, $request, $response ) Wrappers that hides the entries themselves. =back =head2 Matching The following keys on a configuration entry specify matching. For all of these you can provide an array of values instead of a single value. The entry matches if at least one of the values in the array matches. Entries that require match against a response object attribute will never match unless a response object was provided. =over =item m_scheme => $scheme Matches if the URI uses the specified scheme; e.g. "http". =item m_secure => $bool If $bool is TRUE; matches if the URI uses a secure scheme. If $bool is FALSE; matches if the URI does not use a secure scheme. An example of a secure scheme is "https". =item m_host_port => "$hostname:$port" Matches if the URI's host_port method return the specified value. =item m_host => $hostname Matches if the URI's host method returns the specified value. =item m_port => $port Matches if the URI's port method returns the specified value. =item m_domain => ".$domain" Matches if the URI's host method return a value that within the given domain. The hostname "www.example.com" will for instance match the domain ".com". =item m_path => $path Matches if the URI's path method returns the specified value. =item m_path_prefix => $path Matches if the URI's path is the specified path or has the specified path as prefix. =item m_path_match => $Regexp Matches if the regular expression matches the URI's path. Eg. qr/\.html$/. =item m_method => $method Matches if the request method matches the specified value. Eg. "GET" or "POST". =item m_code => $digit =item m_code => $status_code Matches if the response status code matches. If a single digit is specified; matches for all response status codes beginning with that digit. =item m_proxy => $url Matches if the request is to be sent to the given Proxy server. =item m_media_type => "*/*" =item m_media_type => "text/*" =item m_media_type => "html" =item m_media_type => "xhtml" =item m_media_type => "text/html" Matches if the response media type matches. With a value of "html" matches if $response->content_is_html returns TRUE. With a value of "xhtml" matches if $response->content_is_xhtml returns TRUE. =item m_uri__I<$method> => undef Matches if the URI object provides the method. =item m_uri__I<$method> => $string Matches if the URI's $method method returns the given value. =item m_header__I<$field> => $string Matches if either the request or the response have a header $field with the given value. =item m_response_attr__I<$key> => undef =item m_response_attr__I<$key> => $string Matches if the response object has that key, or the entry has the given value. =back =head1 SEE ALSO L, L, L =head1 AUTHOR Gisle Aas =head1 COPYRIGHT AND LICENSE This software is copyright (c) 1994 by Gisle Aas. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. =cut __END__ #ABSTRACT: Configuration for request and response objects lib/perl5/vendor_perl/5.42.0/HTTP/PaxHeader/Headers.pm000444 000000 000000 00000000025 15210655656 022466 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/HTTP/Headers.pm000444 000000 000000 00000060604 15210655656 020526 0ustar00rootwheel000000 000000 package HTTP::Headers; use strict; use warnings; our $VERSION = '7.02'; use Clone qw(clone); use Carp (); # The $TRANSLATE_UNDERSCORE variable controls whether '_' can be used # as a replacement for '-' in header field names. our $TRANSLATE_UNDERSCORE = 1 unless defined $TRANSLATE_UNDERSCORE; # "Good Practice" order of HTTP message headers: # - General-Headers # - Request-Headers # - Response-Headers # - Entity-Headers my @general_headers = qw( Cache-Control Connection Date Pragma Trailer Transfer-Encoding Upgrade Via Warning ); my @request_headers = qw( Accept Accept-Charset Accept-Encoding Accept-Language Authorization Expect From Host If-Match If-Modified-Since If-None-Match If-Range If-Unmodified-Since Max-Forwards Proxy-Authorization Range Referer TE User-Agent ); my @response_headers = qw( Accept-Ranges Age ETag Location Proxy-Authenticate Retry-After Server Vary WWW-Authenticate ); my @entity_headers = qw( Allow Content-Encoding Content-Language Content-Length Content-Location Content-MD5 Content-Range Content-Type Expires Last-Modified ); my %entity_header = map { lc($_) => 1 } @entity_headers; my @header_order = ( @general_headers, @request_headers, @response_headers, @entity_headers, ); # Make alternative representations of @header_order. This is used # for sorting and case matching. my %header_order; my %standard_case; { my $i = 0; for (@header_order) { my $lc = lc $_; $header_order{$lc} = ++$i; $standard_case{$lc} = $_; } } sub new { my($class) = shift; my $self = bless {}, $class; $self->header(@_) if @_; # set up initial headers $self; } sub header { my $self = shift; Carp::croak('Usage: $h->header($field, ...)') unless @_; my(@old); my %seen; while (@_) { my $field = shift; my $op = @_ ? ($seen{lc($field)}++ ? 'PUSH' : 'SET') : 'GET'; @old = $self->_header($field, shift, $op); } return @old if wantarray; return $old[0] if @old <= 1; join(", ", @old); } sub clear { my $self = shift; %$self = (); } sub push_header { my $self = shift; return $self->_header(@_, 'PUSH_H') if @_ == 2; while (@_) { $self->_header(splice(@_, 0, 2), 'PUSH_H'); } } sub init_header { Carp::croak('Usage: $h->init_header($field, $val)') if @_ != 3; shift->_header(@_, 'INIT'); } sub remove_header { my($self, @fields) = @_; my $field; my @values; foreach $field (@fields) { $field =~ tr/_/-/ if $field !~ /^:/ && $TRANSLATE_UNDERSCORE; my $v = delete $self->{lc $field}; push(@values, ref($v) eq 'ARRAY' ? @$v : $v) if defined $v; } return @values; } sub remove_content_headers { my $self = shift; unless (defined(wantarray)) { # fast branch that does not create return object delete @$self{grep $entity_header{$_} || /^content-/, keys %$self}; return; } my $c = ref($self)->new; for my $f (grep $entity_header{$_} || /^content-/, keys %$self) { $c->{$f} = delete $self->{$f}; } if (exists $self->{'::std_case'}) { $c->{'::std_case'} = $self->{'::std_case'}; } $c; } sub _header { my($self, $field, $val, $op) = @_; Carp::croak("Illegal field name '$field'") if rindex($field, ':') > 1 || !length($field); unless ($field =~ /^:/) { $field =~ tr/_/-/ if $TRANSLATE_UNDERSCORE; my $old = $field; $field = lc $field; unless($standard_case{$field} || $self->{'::std_case'}{$field}) { # generate a %std_case entry for this field $old =~ s/\b(\w)/\u$1/g; $self->{'::std_case'}{$field} = $old; } } $op ||= defined($val) ? 'SET' : 'GET'; if ($op eq 'PUSH_H') { # Like PUSH but where we don't care about the return value if (exists $self->{$field}) { my $h = $self->{$field}; if (ref($h) eq 'ARRAY') { push(@$h, ref($val) eq "ARRAY" ? @$val : $val); } else { $self->{$field} = [$h, ref($val) eq "ARRAY" ? @$val : $val] } return; } $self->{$field} = $val; return; } my $h = $self->{$field}; my @old = ref($h) eq 'ARRAY' ? @$h : (defined($h) ? ($h) : ()); unless ($op eq 'GET' || ($op eq 'INIT' && @old)) { if (defined($val)) { my @new = ($op eq 'PUSH') ? @old : (); if (ref($val) ne 'ARRAY') { push(@new, $val); } else { push(@new, @$val); } $self->{$field} = @new > 1 ? \@new : $new[0]; } elsif ($op ne 'PUSH') { delete $self->{$field}; } } @old; } sub _sorted_field_names { my $self = shift; return [ sort { ($header_order{$a} || 999) <=> ($header_order{$b} || 999) || $a cmp $b } grep !/^::/, keys %$self ]; } sub header_field_names { my $self = shift; return map $standard_case{$_} || $self->{'::std_case'}{$_} || $_, @{ $self->_sorted_field_names }, if wantarray; return grep !/^::/, keys %$self; } sub scan { my($self, $sub) = @_; my $key; for $key (@{ $self->_sorted_field_names }) { my $vals = $self->{$key}; if (ref($vals) eq 'ARRAY') { my $val; for $val (@$vals) { $sub->($standard_case{$key} || $self->{'::std_case'}{$key} || $key, $val); } } else { $sub->($standard_case{$key} || $self->{'::std_case'}{$key} || $key, $vals); } } } sub flatten { my($self)=@_; ( map { my $k = $_; map { ( $k => $_ ) } $self->header($_); } $self->header_field_names ); } sub as_string { my($self, $endl) = @_; $endl = "\n" unless defined $endl; my @result = (); for my $key (@{ $self->_sorted_field_names }) { next if index($key, '_') == 0; my $vals = $self->{$key}; if ( ref($vals) eq 'ARRAY' ) { for my $val (@$vals) { $val = '' if not defined $val; my $field = $standard_case{$key} || $self->{'::std_case'}{$key} || $key; $field =~ s/^://; if ( index($val, "\n") >= 0 ) { $val = _process_newline($val, $endl); } push @result, $field . ': ' . $val; } } else { $vals = '' if not defined $vals; my $field = $standard_case{$key} || $self->{'::std_case'}{$key} || $key; $field =~ s/^://; if ( index($vals, "\n") >= 0 ) { $vals = _process_newline($vals, $endl); } push @result, $field . ': ' . $vals; } } join($endl, @result, ''); } sub _process_newline { local $_ = shift; my $endl = shift; # must handle header values with embedded newlines with care s/\s+$//; # trailing newlines and space must go s/\n(\x0d?\n)+/\n/g; # no empty lines s/\n([^\040\t])/\n $1/g; # initial space for continuation s/\n/$endl/g; # substitute with requested line ending $_; } sub _date_header { require HTTP::Date; my($self, $header, $time) = @_; my($old) = $self->_header($header); if (defined $time) { $self->_header($header, HTTP::Date::time2str($time)); } $old =~ s/;.*// if defined($old); HTTP::Date::str2time($old); } sub date { shift->_date_header('Date', @_); } sub expires { shift->_date_header('Expires', @_); } sub if_modified_since { shift->_date_header('If-Modified-Since', @_); } sub if_unmodified_since { shift->_date_header('If-Unmodified-Since', @_); } sub last_modified { shift->_date_header('Last-Modified', @_); } # This is used as a private LWP extension. The Client-Date header is # added as a timestamp to a response when it has been received. sub client_date { shift->_date_header('Client-Date', @_); } # The retry_after field is dual format (can also be a expressed as # number of seconds from now), so we don't provide an easy way to # access it until we have know how both these interfaces can be # addressed. One possibility is to return a negative value for # relative seconds and a positive value for epoch based time values. #sub retry_after { shift->_date_header('Retry-After', @_); } sub content_type { my $self = shift; my $ct = $self->{'content-type'}; $self->{'content-type'} = shift if @_; $ct = $ct->[0] if ref($ct) eq 'ARRAY'; return '' unless defined($ct) && length($ct); my @ct = split(/;\s*/, $ct, 2); for ($ct[0]) { s/\s+//g; $_ = lc($_); } wantarray ? @ct : $ct[0]; } sub content_type_charset { my $self = shift; require HTTP::Headers::Util; my $h = $self->{'content-type'}; $h = $h->[0] if ref($h); $h = "" unless defined $h; my @v = HTTP::Headers::Util::split_header_words($h); if (@v) { my($ct, undef, %ct_param) = @{$v[0]}; my $charset = $ct_param{charset}; if ($ct) { $ct = lc($ct); $ct =~ s/\s+//; } if ($charset) { $charset = uc($charset); $charset =~ s/^\s+//; $charset =~ s/\s+\z//; undef($charset) if $charset eq ""; } return $ct, $charset if wantarray; return $charset; } return undef, undef if wantarray; return undef; } sub content_is_text { my $self = shift; return $self->content_type =~ m,^text/,; } sub content_is_html { my $self = shift; return $self->content_type eq 'text/html' || $self->content_is_xhtml; } sub content_is_xhtml { my $ct = shift->content_type; return $ct eq "application/xhtml+xml" || $ct eq "application/vnd.wap.xhtml+xml"; } sub content_is_xml { my $ct = shift->content_type; return 1 if $ct eq "text/xml"; return 1 if $ct eq "application/xml"; return 1 if $ct =~ /\+xml$/; return 0; } sub referer { my $self = shift; if (@_ && $_[0] =~ /#/) { # Strip fragment per RFC 2616, section 14.36. my $uri = shift; if (ref($uri)) { $uri = $uri->clone; $uri->fragment(undef); } else { $uri =~ s/\#.*//; } unshift @_, $uri; } ($self->_header('Referer', @_))[0]; } *referrer = \&referer; # on tchrist's request sub title { (shift->_header('Title', @_))[0] } sub content_encoding { (shift->_header('Content-Encoding', @_))[0] } sub content_language { (shift->_header('Content-Language', @_))[0] } sub content_length { (shift->_header('Content-Length', @_))[0] } sub user_agent { (shift->_header('User-Agent', @_))[0] } sub server { (shift->_header('Server', @_))[0] } sub from { (shift->_header('From', @_))[0] } sub warning { (shift->_header('Warning', @_))[0] } sub www_authenticate { (shift->_header('WWW-Authenticate', @_))[0] } sub authorization { (shift->_header('Authorization', @_))[0] } sub proxy_authenticate { (shift->_header('Proxy-Authenticate', @_))[0] } sub proxy_authorization { (shift->_header('Proxy-Authorization', @_))[0] } sub authorization_basic { shift->_basic_auth("Authorization", @_) } sub proxy_authorization_basic { shift->_basic_auth("Proxy-Authorization", @_) } sub _basic_auth { require MIME::Base64; my($self, $h, $user, $passwd) = @_; my($old) = $self->_header($h); if (defined $user) { Carp::croak("Basic authorization user name can't contain ':'") if $user =~ /:/; $passwd = '' unless defined $passwd; $self->_header($h => 'Basic ' . MIME::Base64::encode("$user:$passwd", '')); } if (defined $old && $old =~ s/^\s*Basic\s+//) { my $val = MIME::Base64::decode($old); return $val unless wantarray; return split(/:/, $val, 2); } return; } 1; =pod =encoding UTF-8 =head1 NAME HTTP::Headers - Class encapsulating HTTP Message headers =head1 VERSION version 7.02 =head1 SYNOPSIS require HTTP::Headers; $h = HTTP::Headers->new; $h->header('Content-Type' => 'text/plain'); # set $ct = $h->header('Content-Type'); # get $h->remove_header('Content-Type'); # delete =head1 DESCRIPTION The C class encapsulates HTTP-style message headers. The headers consist of attribute-value pairs also called fields, which may be repeated, and which are printed in a particular order. The field names are cases insensitive. Instances of this class are usually created as member variables of the C and C classes, internal to the library. The following methods are available: =over 4 =item $h = HTTP::Headers->new Constructs a new C object. You might pass some initial attribute-value pairs as parameters to the constructor. I: $h = HTTP::Headers->new( Date => 'Thu, 03 Feb 1994 00:00:00 GMT', Content_Type => 'text/html; version=3.2', Content_Base => 'http://www.perl.org/'); The constructor arguments are passed to the C
method which is described below. =item $h->clone Returns a copy of this C object. =item $h->header( $field ) =item $h->header( $field => $value ) =item $h->header( $f1 => $v1, $f2 => $v2, ... ) Get or set the value of one or more header fields. The header field name ($field) is not case sensitive. To make the life easier for perl users who wants to avoid quoting before the => operator, you can use '_' as a replacement for '-' in header names. The header() method accepts multiple ($field => $value) pairs, which means that you can update several fields with a single invocation. The $value argument may be a plain string or a reference to an array of strings for a multi-valued field. If the $value is provided as C then the field is removed. If the $value is not given, then that header field will remain unchanged. In addition to being a string, $value may be something that stringifies. The old value (or values) of the last of the header fields is returned. If no such field exists C will be returned. A multi-valued field will be returned as separate values in list context and will be concatenated with ", " as separator in scalar context. The HTTP spec (RFC 2616) promises that joining multiple values in this way will not change the semantic of a header field, but in practice there are cases like old-style Netscape cookies (see L) where "," is used as part of the syntax of a single field value. Examples: $header->header(MIME_Version => '1.0', User_Agent => 'My-Web-Client/0.01'); $header->header(Accept => "text/html, text/plain, image/*"); $header->header(Accept => [qw(text/html text/plain image/*)]); @accepts = $header->header('Accept'); # get multiple values $accepts = $header->header('Accept'); # get values as a single string =item $h->push_header( $field => $value ) =item $h->push_header( $f1 => $v1, $f2 => $v2, ... ) Add a new field value for the specified header field. Previous values for the same field are retained. As for the header() method, the field name ($field) is not case sensitive and '_' can be used as a replacement for '-'. The $value argument may be a scalar or a reference to a list of scalars. $header->push_header(Accept => 'image/jpeg'); $header->push_header(Accept => [map "image/$_", qw(gif png tiff)]); =item $h->init_header( $field => $value ) Set the specified header to the given value, but only if no previous value for that field is set. The header field name ($field) is not case sensitive and '_' can be used as a replacement for '-'. The $value argument may be a scalar or a reference to a list of scalars. =item $h->remove_header( $field, ... ) This function removes the header fields with the specified names. The header field names ($field) are not case sensitive and '_' can be used as a replacement for '-'. The return value is the values of the fields removed. In scalar context the number of fields removed is returned. Note that if you pass in multiple field names then it is generally not possible to tell which of the returned values belonged to which field. =item $h->remove_content_headers This will remove all the header fields used to describe the content of a message. All header field names prefixed with C fall into this category, as well as C, C and C. RFC 2616 denotes these fields as I. The return value is a new C object that contains the removed headers only. =item $h->clear This will remove all header fields. =item $h->header_field_names Returns the list of distinct names for the fields present in the header. The field names have case as suggested by HTTP spec, and the names are returned in the recommended "Good Practice" order. In scalar context return the number of distinct field names. =item $h->scan( \&process_header_field ) Apply a subroutine to each header field in turn. The callback routine is called with two parameters; the name of the field and a single value (a string). If a header field is multi-valued, then the routine is called once for each value. The field name passed to the callback routine has case as suggested by HTTP spec, and the headers will be visited in the recommended "Good Practice" order. Any return values of the callback routine are ignored. The loop can be broken by raising an exception (C), but the caller of scan() would have to trap the exception itself. =item $h->flatten() Returns the list of pairs of keys and values. =item $h->as_string =item $h->as_string( $eol ) Return the header fields as a formatted MIME header. Since it internally uses the C method to build the string, the result will use case as suggested by HTTP spec, and it will follow recommended "Good Practice" of ordering the header fields. Long header values are not folded. The optional $eol parameter specifies the line ending sequence to use. The default is "\n". Embedded "\n" characters in header field values will be substituted with this line ending sequence. =back =head1 CONVENIENCE METHODS The most frequently used headers can also be accessed through the following convenience methods. Most of these methods can both be used to read and to set the value of a header. The header value is set if you pass an argument to the method. The old header value is always returned. If the given header did not exist then C is returned. Methods that deal with dates/times always convert their value to system time (seconds since Jan 1, 1970) and they also expect this kind of value when the header value is set. =over 4 =item $h->date This header represents the date and time at which the message was originated. I: $h->date(time); # set current date =item $h->expires This header gives the date and time after which the entity should be considered stale. =item $h->if_modified_since =item $h->if_unmodified_since These header fields are used to make a request conditional. If the requested resource has (or has not) been modified since the time specified in this field, then the server will return a C<304 Not Modified> response instead of the document itself. =item $h->last_modified This header indicates the date and time at which the resource was last modified. I: # check if document is more than 1 hour old if (my $last_mod = $h->last_modified) { if ($last_mod < time - 60*60) { ... } } =item $h->content_type The Content-Type header field indicates the media type of the message content. I: $h->content_type('text/html'); The value returned will be converted to lower case, and potential parameters will be chopped off and returned as a separate value if in an array context. If there is no such header field, then the empty string is returned. This makes it safe to do the following: if ($h->content_type eq 'text/html') { # we enter this place even if the real header value happens to # be 'TEXT/HTML; version=3.0' ... } =item $h->content_type_charset Returns the upper-cased charset specified in the Content-Type header. In list context return the lower-cased bare content type followed by the upper-cased charset. Both values will be C if not specified in the header. =item $h->content_is_text Returns TRUE if the Content-Type header field indicate that the content is textual. =item $h->content_is_html Returns TRUE if the Content-Type header field indicate that the content is some kind of HTML (including XHTML). This method can't be used to set Content-Type. =item $h->content_is_xhtml Returns TRUE if the Content-Type header field indicate that the content is XHTML. This method can't be used to set Content-Type. =item $h->content_is_xml Returns TRUE if the Content-Type header field indicate that the content is XML. This method can't be used to set Content-Type. =item $h->content_encoding The Content-Encoding header field is used as a modifier to the media type. When present, its value indicates what additional encoding mechanism has been applied to the resource. =item $h->content_length A decimal number indicating the size in bytes of the message content. =item $h->content_language The natural language(s) of the intended audience for the message content. The value is one or more language tags as defined by RFC 1766. Eg. "no" for some kind of Norwegian and "en-US" for English the way it is written in the US. =item $h->title The title of the document. In libwww-perl this header will be initialized automatically from the ETITLE>...E/TITLE> element of HTML documents. I =item $h->user_agent This header field is used in request messages and contains information about the user agent originating the request. I: $h->user_agent('Mozilla/5.0 (compatible; MSIE 7.0; Windows NT 6.0)'); =item $h->server The server header field contains information about the software being used by the originating server program handling the request. =item $h->from This header should contain an Internet e-mail address for the human user who controls the requesting user agent. The address should be machine-usable, as defined by RFC822. E.g.: $h->from('King Kong '); I =item $h->referer Used to specify the address (URI) of the document from which the requested resource address was obtained. The "Free On-line Dictionary of Computing" as this to say about the word I: A misspelling of "referrer" which somehow made it into the {HTTP} standard. A given {web page}'s referer (sic) is the {URL} of whatever web page contains the link that the user followed to the current page. Most browsers pass this information as part of a request. (1998-10-19) By popular demand C exists as an alias for this method so you can avoid this misspelling in your programs and still send the right thing on the wire. When setting the referrer, this method removes the fragment from the given URI if it is present, as mandated by RFC2616. Note that the removal does I happen automatically if using the header(), push_header() or init_header() methods to set the referrer. =item $h->www_authenticate This header must be included as part of a C<401 Unauthorized> response. The field value consist of a challenge that indicates the authentication scheme and parameters applicable to the requested URI. =item $h->proxy_authenticate This header must be included in a C<407 Proxy Authentication Required> response. =item $h->authorization =item $h->proxy_authorization A user agent that wishes to authenticate itself with a server or a proxy, may do so by including these headers. =item $h->authorization_basic This method is used to get or set an authorization header that use the "Basic Authentication Scheme". In array context it will return two values; the user name and the password. In scalar context it will return I<"uname:password"> as a single string value. When used to set the header value, it expects two arguments. I: $h->authorization_basic($uname, $password); The method will croak if the $uname contains a colon ':'. =item $h->proxy_authorization_basic Same as authorization_basic() but will set the "Proxy-Authorization" header instead. =back =head1 NON-CANONICALIZED FIELD NAMES The header field name spelling is normally canonicalized including the '_' to '-' translation. There are some application where this is not appropriate. Prefixing field names with ':' allow you to force a specific spelling. For example if you really want a header field name to show up as C instead of "Foo-Bar", you might set it like this: $h->header(":foo_bar" => 1); These field names are returned with the ':' intact for $h->header_field_names and the $h->scan callback, but the colons do not show in $h->as_string. =head1 AUTHOR Gisle Aas =head1 COPYRIGHT AND LICENSE This software is copyright (c) 1994 by Gisle Aas. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. =cut __END__ #ABSTRACT: Class encapsulating HTTP Message headers lib/perl5/vendor_perl/5.42.0/HTTP/Headers/PaxHeader/Auth.pm000444 000000 000000 00000000025 15210655656 023367 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/HTTP/Headers/Auth.pm000444 000000 000000 00000004456 15210655656 021432 0ustar00rootwheel000000 000000 package HTTP::Headers::Auth; use strict; use warnings; our $VERSION = '7.02'; use HTTP::Headers; package HTTP::Headers; BEGIN { # we provide a new (and better) implementations below undef(&www_authenticate); undef(&proxy_authenticate); } require HTTP::Headers::Util; sub _parse_authenticate { my @ret; for (HTTP::Headers::Util::split_header_words(@_)) { if (!defined($_->[1])) { # this is a new auth scheme push(@ret, shift(@$_) => {}); shift @$_; } if (@ret) { # this a new parameter pair for the last auth scheme while (@$_) { my $k = shift @$_; my $v = shift @$_; $ret[-1]{$k} = $v; } } else { # something wrong, parameter pair without any scheme seen # IGNORE } } @ret; } sub _authenticate { my $self = shift; my $header = shift; my @old = $self->_header($header); if (@_) { $self->remove_header($header); my @new = @_; while (@new) { my $a_scheme = shift(@new); if ($a_scheme =~ /\s/) { # assume complete valid value, pass it through $self->push_header($header, $a_scheme); } else { my @param; if (@new) { my $p = $new[0]; if (ref($p) eq "ARRAY") { @param = @$p; shift(@new); } elsif (ref($p) eq "HASH") { @param = %$p; shift(@new); } } my $val = ucfirst(lc($a_scheme)); if (@param) { my $sep = " "; while (@param) { my $k = shift @param; my $v = shift @param; if ($v =~ /[^0-9a-zA-Z]/ || lc($k) eq "realm") { # must quote the value $v =~ s,([\\\"]),\\$1,g; $v = qq("$v"); } $val .= "$sep$k=$v"; $sep = ", "; } } $self->push_header($header, $val); } } } return unless defined wantarray; wantarray ? _parse_authenticate(@old) : join(", ", @old); } sub www_authenticate { shift->_authenticate("WWW-Authenticate", @_) } sub proxy_authenticate { shift->_authenticate("Proxy-Authenticate", @_) } 1; __END__ =pod =encoding UTF-8 =head1 NAME HTTP::Headers::Auth =head1 VERSION version 7.02 =head1 AUTHOR Gisle Aas =head1 COPYRIGHT AND LICENSE This software is copyright (c) 1994 by Gisle Aas. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. =cut lib/perl5/vendor_perl/5.42.0/HTTP/Headers/PaxHeader/ETag.pm000444 000000 000000 00000000025 15210655656 023306 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/HTTP/Headers/ETag.pm000444 000000 000000 00000004766 15210655656 021355 0ustar00rootwheel000000 000000 package HTTP::Headers::ETag; use strict; use warnings; our $VERSION = '7.02'; require HTTP::Date; require HTTP::Headers; package HTTP::Headers; sub _etags { my $self = shift; my $header = shift; my @old = _split_etag_list($self->_header($header)); if (@_) { $self->_header($header => join(", ", _split_etag_list(@_))); } wantarray ? @old : join(", ", @old); } sub etag { shift->_etags("ETag", @_); } sub if_match { shift->_etags("If-Match", @_); } sub if_none_match { shift->_etags("If-None-Match", @_); } sub if_range { # Either a date or an entity-tag my $self = shift; my @old = $self->_header("If-Range"); if (@_) { my $new = shift; if (!defined $new) { $self->remove_header("If-Range"); } elsif ($new =~ /^\d+$/) { $self->_date_header("If-Range", $new); } else { $self->_etags("If-Range", $new); } } return unless defined(wantarray); for (@old) { my $t = HTTP::Date::str2time($_); $_ = $t if $t; } wantarray ? @old : join(", ", @old); } # Split a list of entity tag values. The return value is a list # consisting of one element per entity tag. Suitable for parsing # headers like C, C. You might even want to # use it on C and C entity tag values, because it will # normalize them to the common form. # # entity-tag = [ weak ] opaque-tag # weak = "W/" # opaque-tag = quoted-string sub _split_etag_list { my(@val) = @_; my @res; for (@val) { while (length) { my $weak = ""; $weak = "W/" if s,^\s*[wW]/,,; my $etag = ""; if (s/^\s*(\"[^\"\\]*(?:\\.[^\"\\]*)*\")//) { push(@res, "$weak$1"); } elsif (s/^\s*,//) { push(@res, qq(W/"")) if $weak; } elsif (s/^\s*([^,\s]+)//) { $etag = $1; $etag =~ s/([\"\\])/\\$1/g; push(@res, qq($weak"$etag")); } elsif (s/^\s+// || !length) { push(@res, qq(W/"")) if $weak; } else { die "This should not happen: '$_'"; } } } @res; } 1; __END__ =pod =encoding UTF-8 =head1 NAME HTTP::Headers::ETag =head1 VERSION version 7.02 =head1 AUTHOR Gisle Aas =head1 COPYRIGHT AND LICENSE This software is copyright (c) 1994 by Gisle Aas. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. =cut lib/perl5/vendor_perl/5.42.0/HTTP/Headers/PaxHeader/Util.pm000444 000000 000000 00000000025 15210655656 023403 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/HTTP/Headers/Util.pm000444 000000 000000 00000011740 15210655656 021440 0ustar00rootwheel000000 000000 package HTTP::Headers::Util; use strict; use warnings; our $VERSION = '7.02'; use Exporter 5.57 'import'; our @EXPORT_OK=qw(split_header_words _split_header_words join_header_words); sub split_header_words { my @res = &_split_header_words; for my $arr (@res) { for (my $i = @$arr - 2; $i >= 0; $i -= 2) { $arr->[$i] = lc($arr->[$i]); } } return @res; } sub _split_header_words { my(@val) = @_; my @res; for (@val) { my @cur; while (length) { if (s/^\s*(=*[^\s=;,]+)//) { # 'token' or parameter 'attribute' push(@cur, $1); # a quoted value if (s/^\s*=\s*\"([^\"\\]*(?:\\.[^\"\\]*)*)\"//) { my $val = $1; $val =~ s/\\(.)/$1/g; push(@cur, $val); # some unquoted value } elsif (s/^\s*=\s*([^;,\s]*)//) { my $val = $1; $val =~ s/\s+$//; push(@cur, $val); # no value, a lone token } else { push(@cur, undef); } } elsif (s/^\s*,//) { push(@res, [@cur]) if @cur; @cur = (); } elsif (s/^\s*;// || s/^\s+// || s/^=//) { # continue } else { die "This should not happen: '$_'"; } } push(@res, \@cur) if @cur; } @res; } sub join_header_words { @_ = ([@_]) if @_ && !ref($_[0]); my @res; for (@_) { my @cur = @$_; my @attr; while (@cur) { my $k = shift @cur; my $v = shift @cur; if (defined $v) { if ($v =~ /[\x00-\x20()<>@,;:\\\"\/\[\]?={}\x7F-\xFF]/ || !length($v)) { $v =~ s/([\"\\])/\\$1/g; # escape " and \ $k .= qq(="$v"); } else { # token $k .= "=$v"; } } push(@attr, $k); } push(@res, join("; ", @attr)) if @attr; } join(", ", @res); } 1; =pod =encoding UTF-8 =head1 NAME HTTP::Headers::Util - Header value parsing utility functions =head1 VERSION version 7.02 =head1 SYNOPSIS use HTTP::Headers::Util qw(split_header_words); @values = split_header_words($h->header("Content-Type")); =head1 DESCRIPTION This module provides a few functions that helps parsing and construction of valid HTTP header values. None of the functions are exported by default. The following functions are available: =over 4 =item split_header_words( @header_values ) This function will parse the header values given as argument into a list of anonymous arrays containing key/value pairs. The function knows how to deal with ",", ";" and "=" as well as quoted values after "=". A list of space separated tokens are parsed as if they were separated by ";". If the @header_values passed as argument contains multiple values, then they are treated as if they were a single value separated by comma ",". This means that this function is useful for parsing header fields that follow this syntax (BNF as from the HTTP/1.1 specification, but we relax the requirement for tokens). headers = #header header = (token | parameter) *( [";"] (token | parameter)) token = 1* separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <"> | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT quoted-string = ( <"> *(qdtext | quoted-pair ) <"> ) qdtext = > quoted-pair = "\" CHAR parameter = attribute "=" value attribute = token value = token | quoted-string Each I
is represented by an anonymous array of key/value pairs. The keys will be all be forced to lower case. The value for a simple token (not part of a parameter) is C. Syntactically incorrect headers will not necessarily be parsed as you would want. This is easier to describe with some examples: split_header_words('foo="bar"; port="80,81"; DISCARD, BAR=baz'); split_header_words('text/html; charset="iso-8859-1"'); split_header_words('Basic realm="\\"foo\\\\bar\\""'); will return [foo=>'bar', port=>'80,81', discard=> undef], [bar=>'baz' ] ['text/html' => undef, charset => 'iso-8859-1'] [basic => undef, realm => "\"foo\\bar\""] If you don't want the function to convert tokens and attribute keys to lower case you can call it as C<_split_header_words> instead (with a leading underscore). =item join_header_words( @arrays ) This will do the opposite of the conversion done by split_header_words(). It takes a list of anonymous arrays as arguments (or a list of key/value pairs) and produces a single header value. Attribute values are quoted if needed. Example: join_header_words(["text/plain" => undef, charset => "iso-8859/1"]); join_header_words("text/plain" => undef, charset => "iso-8859/1"); will both return the string: text/plain; charset="iso-8859/1" =back =head1 AUTHOR Gisle Aas =head1 COPYRIGHT AND LICENSE This software is copyright (c) 1994 by Gisle Aas. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. =cut __END__ #ABSTRACT: Header value parsing utility functions lib/perl5/vendor_perl/5.42.0/HTTP/PaxHeader/Message.pm000444 000000 000000 00000000025 15210655656 022477 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/HTTP/Message.pm000444 000000 000000 00000102567 15210655656 020544 0ustar00rootwheel000000 000000 package HTTP::Message; use strict; use warnings; our $VERSION = '7.02'; require HTTP::Headers; require Carp; our $MAXIMUM_BODY_SIZE; my $CRLF = "\015\012"; # "\r\n" is not portable unless ($HTTP::URI_CLASS) { if ($ENV{PERL_HTTP_URI_CLASS} && $ENV{PERL_HTTP_URI_CLASS} =~ /^([\w:]+)$/) { $HTTP::URI_CLASS = $1; } else { $HTTP::URI_CLASS = "URI"; } } eval "require $HTTP::URI_CLASS"; die $@ if $@; *_utf8_downgrade = defined(&utf8::downgrade) ? sub { utf8::downgrade($_[0], 1) or Carp::croak("HTTP::Message content must be bytes") } : sub { }; sub new { my($class, $header, $content) = @_; if (defined $header) { Carp::croak("Bad header argument") unless ref $header; if (ref($header) eq "ARRAY") { $header = HTTP::Headers->new(@$header); } else { $header = $header->clone; } } else { $header = HTTP::Headers->new; } if (defined $content) { _utf8_downgrade($content); } else { $content = ''; } bless { '_headers' => $header, '_content' => $content, '_max_body_size' => $HTTP::Message::MAXIMUM_BODY_SIZE, }, $class; } sub parse { my($class, $str) = @_; my @hdr; while (1) { if ($str =~ s/^([^\s:]+)[ \t]*: ?(.*)\n?//) { push(@hdr, $1, $2); $hdr[-1] =~ s/\r\z//; } elsif (@hdr && $str =~ s/^([ \t].*)\n?//) { $hdr[-1] .= "\n$1"; $hdr[-1] =~ s/\r\z//; } else { $str =~ s/^\r?\n//; last; } } local $HTTP::Headers::TRANSLATE_UNDERSCORE; new($class, \@hdr, $str); } sub clone { my $self = shift; my $clone = HTTP::Message->new($self->headers, $self->content); $clone->protocol($self->protocol); $clone; } sub clear { my $self = shift; $self->{_headers}->clear; $self->content(""); delete $self->{_parts}; return; } sub protocol { shift->_elem('_protocol', @_); } sub headers { my $self = shift; # recalculation of _content might change headers, so we # need to force it now $self->_content unless exists $self->{_content}; $self->{_headers}; } sub headers_as_string { shift->headers->as_string(@_); } sub content { my $self = $_[0]; if (defined(wantarray)) { $self->_content unless exists $self->{_content}; my $old = $self->{_content}; $old = $$old if ref($old) eq "SCALAR"; &_set_content if @_ > 1; return $old; } if (@_ > 1) { &_set_content; } else { Carp::carp("Useless content call in void context") if $^W; } } sub _set_content { my $self = $_[0]; _utf8_downgrade($_[1]); if (!ref($_[1]) && ref($self->{_content}) eq "SCALAR") { ${$self->{_content}} = defined( $_[1] ) ? $_[1] : ''; } else { die "Can't set content to be a scalar reference" if ref($_[1]) eq "SCALAR"; $self->{_content} = defined( $_[1] ) ? $_[1] : ''; delete $self->{_content_ref}; } delete $self->{_parts} unless $_[2]; } sub add_content { my $self = shift; $self->_content unless exists $self->{_content}; my $chunkref = \$_[0]; $chunkref = $$chunkref if ref($$chunkref); # legacy _utf8_downgrade($$chunkref); my $ref = ref($self->{_content}); if (!$ref) { $self->{_content} .= $$chunkref; } elsif ($ref eq "SCALAR") { ${$self->{_content}} .= $$chunkref; } else { Carp::croak("Can't append to $ref content"); } delete $self->{_parts}; } sub add_content_utf8 { my($self, $buf) = @_; utf8::upgrade($buf); utf8::encode($buf); $self->add_content($buf); } sub content_ref { my $self = shift; $self->_content unless exists $self->{_content}; delete $self->{_parts}; my $old = \$self->{_content}; my $old_cref = $self->{_content_ref}; if (@_) { my $new = shift; Carp::croak("Setting content_ref to a non-ref") unless ref($new); delete $self->{_content}; # avoid modifying $$old $self->{_content} = $new; $self->{_content_ref}++; } $old = $$old if $old_cref; return $old; } sub content_charset { my $self = shift; if (my $charset = $self->content_type_charset) { return $charset; } # time to start guessing my $cref = $self->decoded_content(ref => 1, charset => "none"); # Unicode BOM for ($$cref) { return "UTF-8" if /^\xEF\xBB\xBF/; return "UTF-32LE" if /^\xFF\xFE\x00\x00/; return "UTF-32BE" if /^\x00\x00\xFE\xFF/; return "UTF-16LE" if /^\xFF\xFE/; return "UTF-16BE" if /^\xFE\xFF/; } if ($self->content_is_xml) { # http://www.w3.org/TR/2006/REC-xml-20060816/#sec-guessing # XML entity not accompanied by external encoding information and not # in UTF-8 or UTF-16 encoding must begin with an XML encoding declaration, # in which the first characters must be ')/) { if ($1 =~ /\sencoding\s*=\s*(["'])(.*?)\1/) { my $enc = $2; $enc =~ s/^\s+//; $enc =~ s/\s+\z//; return $enc if $enc; } } } return "UTF-8"; } elsif ($self->content_is_html) { # look for or # http://dev.w3.org/html5/spec/Overview.html#determining-the-character-encoding require IO::HTML; # Use relaxed search to match previous versions of HTTP::Message: my $encoding = IO::HTML::find_charset_in($$cref, { encoding => 1, need_pragma => 0 }); return $encoding->mime_name if $encoding; } elsif ($self->content_type eq "application/json") { for ($$cref) { # RFC 4627, ch 3 return "UTF-32BE" if /^\x00\x00\x00./s; return "UTF-32LE" if /^.\x00\x00\x00/s; return "UTF-16BE" if /^\x00.\x00./s; return "UTF-16LE" if /^.\x00.\x00/s; return "UTF-8"; } } if ($self->content_type =~ /^text\//) { for ($$cref) { if (length) { return "US-ASCII" unless /[\x80-\xFF]/; require Encode; eval { Encode::decode_utf8($_, Encode::FB_CROAK() | Encode::LEAVE_SRC()); }; return "UTF-8" unless $@; return "ISO-8859-1"; } } } return undef; } sub max_body_size { my $self = $_[0]; my $old = $self->{_max_body_size}; $self->_set_max_body_size($_[1]) if @_ > 1; return $old; } sub _set_max_body_size { my $self = $_[0]; $self->{_max_body_size} = $_[1]; } sub decoded_content { my($self, %opt) = @_; my $content_ref; my $content_ref_iscopy; eval { $content_ref = $self->content_ref; die "Can't decode ref content" if ref($content_ref) ne "SCALAR"; my $content_limit = exists $opt{ max_body_size } ? $opt{ max_body_size } : defined $self->max_body_size ? $self->max_body_size : undef ; my %limiter_options; if( defined $content_limit ) { %limiter_options = (LimitOutput => 1, Bufsize => $content_limit); }; if (my $h = $self->header("Content-Encoding")) { $h =~ s/^\s+//; $h =~ s/\s+$//; for my $ce (reverse split(/\s*,\s*/, lc($h))) { next unless $ce; next if $ce eq "identity" || $ce eq "none"; if ($ce eq "gzip" || $ce eq "x-gzip") { require Compress::Raw::Zlib; # 'WANT_GZIP_OR_ZLIB', 'Z_BUF_ERROR'; if( ! $content_ref_iscopy and keys %limiter_options) { # Create a copy of the input because Zlib will overwrite it # :-( my $input = "$$content_ref"; $content_ref = \$input; $content_ref_iscopy++; }; my ($i, $status) = Compress::Raw::Zlib::Inflate->new( %limiter_options, ConsumeInput => 0, # overridden by Zlib if we have %limiter_options :-( WindowBits => Compress::Raw::Zlib::WANT_GZIP_OR_ZLIB(), ); my $res = $i->inflate( $content_ref, \my $output ); $res == Compress::Raw::Zlib::Z_BUF_ERROR() and Carp::croak("Decoded content would be larger than $content_limit octets"); $res == Compress::Raw::Zlib::Z_OK() or $res == Compress::Raw::Zlib::Z_STREAM_END() or die "Can't gunzip content: $res"; $content_ref = \$output; $content_ref_iscopy++; } elsif ($ce eq 'br') { require IO::Uncompress::Brotli; my $bro = IO::Uncompress::Brotli->create; my $output; if( defined $content_limit ) { $output = eval { $bro->decompress( $$content_ref, $content_limit ); } } else { $output = eval { $bro->decompress($$content_ref) }; } $@ and die "Can't unbrotli content: $@"; $content_ref = \$output; $content_ref_iscopy++; } elsif ($ce eq "x-bzip2" or $ce eq "bzip2") { require Compress::Raw::Bzip2; if( ! $content_ref_iscopy ) { # Create a copy of the input because Bzlib2 will overwrite it # :-( my $input = "$$content_ref"; $content_ref = \$input; $content_ref_iscopy++; }; my ($i, $status) = Compress::Raw::Bunzip2->new( 1, # appendInput 0, # consumeInput 0, # small $limiter_options{ LimitOutput } || 0, ); my $output; $output = "\0" x $limiter_options{ Bufsize } if $limiter_options{ Bufsize }; my $res = $i->bzinflate( $content_ref, \$output ); $res == Compress::Raw::Bzip2::BZ_OUTBUFF_FULL() and Carp::croak("Decoded content would be larger than $content_limit octets"); $res == Compress::Raw::Bzip2::BZ_OK() or $res == Compress::Raw::Bzip2::BZ_STREAM_END() or die "Can't bunzip content: $res"; $content_ref = \$output; $content_ref_iscopy++; } elsif ($ce eq "deflate") { require IO::Uncompress::Inflate; my $output; my $status = IO::Uncompress::Inflate::inflate($content_ref, \$output, Transparent => 0); my $error = $IO::Uncompress::Inflate::InflateError; unless ($status) { # "Content-Encoding: deflate" is supposed to mean the # "zlib" format of RFC 1950, but Microsoft got that # wrong, so some servers sends the raw compressed # "deflate" data. This tries to inflate this format. $output = undef; require IO::Uncompress::RawInflate; unless (IO::Uncompress::RawInflate::rawinflate($content_ref, \$output)) { $self->push_header("Client-Warning" => "Could not raw inflate content: $IO::Uncompress::RawInflate::RawInflateError"); $output = undef; } } die "Can't inflate content: $error" unless defined $output; $content_ref = \$output; $content_ref_iscopy++; } elsif ($ce eq "compress" || $ce eq "x-compress") { die "Can't uncompress content"; } elsif ($ce eq "base64") { # not really C-T-E, but should be harmless require MIME::Base64; $content_ref = \MIME::Base64::decode($$content_ref); $content_ref_iscopy++; } elsif ($ce eq "quoted-printable") { # not really C-T-E, but should be harmless require MIME::QuotedPrint; $content_ref = \MIME::QuotedPrint::decode($$content_ref); $content_ref_iscopy++; } else { die "Don't know how to decode Content-Encoding '$ce'"; } } } if ($self->content_is_text || (my $is_xml = $self->content_is_xml)) { my $charset = lc( $opt{charset} || $self->content_type_charset || $opt{default_charset} || $self->content_charset || "ISO-8859-1" ); if ($charset eq "none") { # leave it as is } elsif ($charset eq "us-ascii" || $charset eq "iso-8859-1") { if ($$content_ref =~ /[^\x00-\x7F]/ && defined &utf8::upgrade) { unless ($content_ref_iscopy) { my $copy = $$content_ref; $content_ref = \$copy; $content_ref_iscopy++; } utf8::upgrade($$content_ref); } } else { require Encode; eval { $content_ref = \Encode::decode($charset, $$content_ref, ($opt{charset_strict} ? Encode::FB_CROAK() : 0) | Encode::LEAVE_SRC()); }; if ($@) { my $retried; if ($@ =~ /^Unknown encoding/) { my $alt_charset = lc($opt{alt_charset} || ""); if ($alt_charset && $charset ne $alt_charset) { # Retry decoding with the alternative charset $content_ref = \Encode::decode($alt_charset, $$content_ref, ($opt{charset_strict} ? Encode::FB_CROAK() : 0) | Encode::LEAVE_SRC()) unless $alt_charset eq "none"; $retried++; } } die unless $retried; } die "Encode::decode() returned undef improperly" unless defined $$content_ref; if ($is_xml) { # Get rid of the XML encoding declaration if present $$content_ref =~ s/^\x{FEFF}//; if ($$content_ref =~ /^(\s*<\?xml[^\x00]*?\?>)/) { substr($$content_ref, 0, length($1)) =~ s/\sencoding\s*=\s*(["']).*?\1//; } } } } }; if ($@) { Carp::croak($@) if $opt{raise_error}; return undef; } return $opt{ref} ? $content_ref : $$content_ref; } sub decodable { # should match the Content-Encoding values that decoded_content can deal with my $self = shift; my @enc; local $@; # XXX preferably we should determine if the modules are available without loading # them here eval { require Compress::Raw::Zlib; push(@enc, "gzip", "x-gzip"); }; eval { require IO::Uncompress::Inflate; require IO::Uncompress::RawInflate; push(@enc, "deflate"); }; eval { require Compress::Raw::Bzip2; push(@enc, "x-bzip2", "bzip2"); }; eval { require IO::Uncompress::Brotli; push(@enc, 'br'); }; # we don't care about announcing the 'identity', 'base64' and # 'quoted-printable' stuff return wantarray ? @enc : join(", ", @enc); } sub decode { my $self = shift; return 1 unless $self->header("Content-Encoding"); if (defined(my $content = $self->decoded_content(charset => "none"))) { $self->remove_header("Content-Encoding", "Content-Length", "Content-MD5"); $self->content($content); return 1; } return 0; } sub encode { my($self, @enc) = @_; Carp::croak("Can't encode multipart/* messages") if $self->content_type =~ m,^multipart/,; Carp::croak("Can't encode message/* messages") if $self->content_type =~ m,^message/,; return 1 unless @enc; # nothing to do my $content = $self->content; for my $encoding (@enc) { if ($encoding eq "identity" || $encoding eq "none") { # nothing to do } elsif ($encoding eq "base64") { require MIME::Base64; $content = MIME::Base64::encode($content); } elsif ($encoding eq "gzip" || $encoding eq "x-gzip") { require IO::Compress::Gzip; my $output; IO::Compress::Gzip::gzip(\$content, \$output, Minimal => 1) or die "Can't gzip content: $IO::Compress::Gzip::GzipError"; $content = $output; } elsif ($encoding eq "deflate") { require IO::Compress::Deflate; my $output; IO::Compress::Deflate::deflate(\$content, \$output) or die "Can't deflate content: $IO::Compress::Deflate::DeflateError"; $content = $output; } elsif ($encoding eq "x-bzip2" || $encoding eq "bzip2") { require IO::Compress::Bzip2; my $output; IO::Compress::Bzip2::bzip2(\$content, \$output) or die "Can't bzip2 content: $IO::Compress::Bzip2::Bzip2Error"; $content = $output; } elsif ($encoding eq "br") { require IO::Compress::Brotli; my $output; eval { $output = IO::Compress::Brotli::bro($content) } or die "Can't brotli content: $@"; $content = $output; } elsif ($encoding eq "rot13") { # for the fun of it $content =~ tr/A-Za-z/N-ZA-Mn-za-m/; } else { return 0; } } my $h = $self->header("Content-Encoding"); unshift(@enc, $h) if $h; $self->header("Content-Encoding", join(", ", @enc)); $self->remove_header("Content-Length", "Content-MD5"); $self->content($content); return 1; } sub as_string { my($self, $eol) = @_; $eol = "\n" unless defined $eol; # The calculation of content might update the headers # so we need to do that first. my $content = $self->content; return join("", $self->{'_headers'}->as_string($eol), $eol, $content, (@_ == 1 && length($content) && $content !~ /\n\z/) ? "\n" : "", ); } sub dump { my($self, %opt) = @_; my $content = $self->content; my $chopped = 0; if (!ref($content)) { my $maxlen = $opt{maxlength}; $maxlen = 512 unless defined($maxlen); if ($maxlen && length($content) > $maxlen * 1.1 + 3) { $chopped = length($content) - $maxlen; $content = substr($content, 0, $maxlen) . "..."; } $content =~ s/\\/\\\\/g; $content =~ s/\t/\\t/g; $content =~ s/\r/\\r/g; # no need for 3 digits in escape for these $content =~ s/([\0-\11\13-\037])(?!\d)/sprintf('\\%o',ord($1))/eg; $content =~ s/([\0-\11\13-\037\177-\377])/sprintf('\\x%02X',ord($1))/eg; $content =~ s/([^\12\040-\176])/sprintf('\\x{%X}',ord($1))/eg; # remaining whitespace $content =~ s/( +)\n/("\\40" x length($1)) . "\n"/eg; $content =~ s/(\n+)\n/("\\n" x length($1)) . "\n"/eg; $content =~ s/\n\z/\\n/; my $no_content = $opt{no_content}; $no_content = "(no content)" unless defined $no_content; if ($content eq $no_content) { # escape our $no_content marker $content =~ s/^(.)/sprintf('\\x%02X',ord($1))/eg; } elsif ($content eq "") { $content = $no_content; } } my @dump; push(@dump, $opt{preheader}) if $opt{preheader}; push(@dump, $self->{_headers}->as_string, $content); push(@dump, "(+ $chopped more bytes not shown)") if $chopped; my $dump = join("\n", @dump, ""); $dump =~ s/^/$opt{prefix}/gm if $opt{prefix}; print $dump unless defined wantarray; return $dump; } # allow subclasses to override what will handle individual parts sub _part_class { return __PACKAGE__; } sub parts { my $self = shift; if (defined(wantarray) && (!exists $self->{_parts} || ref($self->{_content}) eq "SCALAR")) { $self->_parts; } my $old = $self->{_parts}; if (@_) { my @parts = map { ref($_) eq 'ARRAY' ? @$_ : $_ } @_; my $ct = $self->content_type || ""; if ($ct =~ m,^message/,) { Carp::croak("Only one part allowed for $ct content") if @parts > 1; } elsif ($ct !~ m,^multipart/,) { $self->remove_content_headers; $self->content_type("multipart/mixed"); } $self->{_parts} = \@parts; _stale_content($self); } return @$old if wantarray; return $old->[0]; } sub add_part { my $self = shift; if (($self->content_type || "") !~ m,^multipart/,) { my $p = $self->_part_class->new( $self->remove_content_headers, $self->content(""), ); $self->content_type("multipart/mixed"); $self->{_parts} = []; if ($p->headers->header_field_names || $p->content ne "") { push(@{$self->{_parts}}, $p); } } elsif (!exists $self->{_parts} || ref($self->{_content}) eq "SCALAR") { $self->_parts; } push(@{$self->{_parts}}, @_); _stale_content($self); return; } sub _stale_content { my $self = shift; if (ref($self->{_content}) eq "SCALAR") { # must recalculate now $self->_content; } else { # just invalidate cache delete $self->{_content}; delete $self->{_content_ref}; } } # delegate all other method calls to the headers object. our $AUTOLOAD; sub AUTOLOAD { my ( $package, $method ) = $AUTOLOAD =~ m/\A(.+)::([^:]*)\z/; my $code = $_[0]->can($method); Carp::croak( qq(Can't locate object method "$method" via package "$package")) unless $code; goto &$code; } sub can { my ( $self, $method ) = @_; if ( my $own_method = $self->SUPER::can($method) ) { return $own_method; } my $headers = ref($self) ? $self->headers : 'HTTP::Headers'; if ( $headers->can($method) ) { # We create the function here so that it will not need to be # autoloaded or recreated the next time. no strict 'refs'; *$method = sub { local $Carp::Internal{ +__PACKAGE__ } = 1; shift->headers->$method(@_); }; return \&$method; } return undef; } sub DESTROY { } # avoid AUTOLOADing it # Private method to access members in %$self sub _elem { my $self = shift; my $elem = shift; my $old = $self->{$elem}; $self->{$elem} = $_[0] if @_; return $old; } # Create private _parts attribute from current _content sub _parts { my $self = shift; my $ct = $self->content_type; if ($ct =~ m,^multipart/,) { require HTTP::Headers::Util; my @h = HTTP::Headers::Util::split_header_words($self->header("Content-Type")); die "Assert" unless @h; my %h = @{$h[0]}; if (defined(my $b = $h{boundary})) { my $str = $self->content; $str =~ s/\r?\n--\Q$b\E--.*//s; if ($str =~ s/(^|.*?\r?\n)--\Q$b\E\r?\n//s) { $self->{_parts} = [map $self->_part_class->parse($_), split(/\r?\n--\Q$b\E\r?\n/, $str)] } } } elsif ($ct eq "message/http") { require HTTP::Request; require HTTP::Response; my $content = $self->content; my $class = ($content =~ m,^(HTTP/.*)\n,) ? "HTTP::Response" : "HTTP::Request"; $self->{_parts} = [$class->parse($content)]; } elsif ($ct =~ m,^message/,) { $self->{_parts} = [ $self->_part_class->parse($self->content) ]; } $self->{_parts} ||= []; } # Create private _content attribute from current _parts sub _content { my $self = shift; my $ct = $self->{_headers}->header("Content-Type") || "multipart/mixed"; if ($ct =~ m,^\s*message/,i) { _set_content($self, $self->{_parts}[0]->as_string($CRLF), 1); return; } require HTTP::Headers::Util; my @v = HTTP::Headers::Util::split_header_words($ct); Carp::carp("Multiple Content-Type headers") if @v > 1; @v = @{$v[0]}; my $boundary; my $boundary_index; for (my @tmp = @v; @tmp;) { my($k, $v) = splice(@tmp, 0, 2); if ($k eq "boundary") { $boundary = $v; $boundary_index = @v - @tmp - 1; last; } } my @parts = map $_->as_string($CRLF), @{$self->{_parts}}; my $bno = 0; $boundary = _boundary() unless defined $boundary; CHECK_BOUNDARY: { for (@parts) { if (index($_, $boundary) >= 0) { # must have a better boundary $boundary = _boundary(++$bno); redo CHECK_BOUNDARY; } } } if ($boundary_index) { $v[$boundary_index] = $boundary; } else { push(@v, boundary => $boundary); } $ct = HTTP::Headers::Util::join_header_words(@v); $self->{_headers}->header("Content-Type", $ct); _set_content($self, "--$boundary$CRLF" . join("$CRLF--$boundary$CRLF", @parts) . "$CRLF--$boundary--$CRLF", 1); } sub _boundary { my $size = shift || return "xYzZY"; require MIME::Base64; my $b = MIME::Base64::encode(join("", map chr(rand(256)), 1..$size*3), ""); $b =~ s/[\W]/X/g; # ensure alnum only $b; } 1; =pod =encoding UTF-8 =head1 NAME HTTP::Message - HTTP style message (base class) =head1 VERSION version 7.02 =head1 SYNOPSIS use parent 'HTTP::Message'; =head1 DESCRIPTION An C object contains some headers and a content body. The following methods are available: =over 4 =item $mess = HTTP::Message->new =item $mess = HTTP::Message->new( $headers ) =item $mess = HTTP::Message->new( $headers, $content ) This constructs a new message object. Normally you would want construct C or C objects instead. The optional $header argument should be a reference to an C object or a plain array reference of key/value pairs. If an C object is provided then a copy of it will be embedded into the constructed message, i.e. it will not be owned and can be modified afterwards without affecting the message. The optional $content argument should be a string of bytes. =item $mess = HTTP::Message->parse( $str ) This constructs a new message object by parsing the given string. =item $mess->headers Returns the embedded C object. =item $mess->headers_as_string =item $mess->headers_as_string( $eol ) Call the as_string() method for the headers in the message. This will be the same as $mess->headers->as_string but it will make your program a whole character shorter :-) =item $mess->content =item $mess->content( $bytes ) The content() method sets the raw content if an argument is given. If no argument is given the content is not touched. In either case the original raw content is returned. If the C argument is given, the content is reset to its default value, which is an empty string. Note that the content should be a string of bytes. Strings in perl can contain characters outside the range of a byte. The C module can be used to turn such strings into a string of bytes. =item $mess->add_content( $bytes ) The add_content() methods appends more data bytes to the end of the current content buffer. =item $mess->add_content_utf8( $string ) The add_content_utf8() method appends the UTF-8 bytes representing the string to the end of the current content buffer. =item $mess->content_ref =item $mess->content_ref( \$bytes ) The content_ref() method will return a reference to content buffer string. It can be more efficient to access the content this way if the content is huge, and it can even be used for direct manipulation of the content, for instance: ${$res->content_ref} =~ s/\bfoo\b/bar/g; This example would modify the content buffer in-place. If an argument is passed it will setup the content to reference some external source. The content() and add_content() methods will automatically dereference scalar references passed this way. For other references content() will return the reference itself and add_content() will refuse to do anything. =item $mess->content_charset This returns the charset used by the content in the message. The charset is either found as the charset attribute of the C header or by guessing. See L for details about how charset is determined. =item $mess->decoded_content( %options ) Returns the content with any C undone and, for textual content (C values starting with C, exactly matching C, or ending with C<+xml>), the raw content's character set decoded into Perl's Unicode string format. Note that this L attempt to decode declared character sets for any other content types like C or C. If the C or C of the message is unknown, this method will fail by returning C. The following options can be specified. =over =item C This overrides the charset parameter for text content. The value C can used to suppress decoding of the charset. =item C This overrides the default charset guessed by content_charset() or if that fails "ISO-8859-1". =item C If decoding fails because the charset specified in the Content-Type header isn't recognized by Perl's Encode module, then try decoding using this charset instead of failing. The C might be specified as C to simply return the string without any decoding of charset as alternative. =item C Abort decoding if malformed characters is found in the content. By default you get the substitution character ("\x{FFFD}") in place of malformed characters. =item C If TRUE then raise an exception if not able to decode content. Reason might be that the specified C or C is not supported. If this option is FALSE, then decoded_content() will return C on errors, but will still set $@. =item C If TRUE then a reference to decoded content is returned. This might be more efficient in cases where the decoded content is identical to the raw content as no data copying is required in this case. =back =item $mess->decodable =item HTTP::Message::decodable() This returns the encoding identifiers that decoded_content() can process. In scalar context returns a comma separated string of identifiers. This value is suitable for initializing the C request header field. =item $mess->decode This method tries to replace the content of the message with the decoded version and removes the C header. Returns TRUE if successful and FALSE if not. If the message does not have a C header this method does nothing and returns TRUE. Note that the content of the message is still bytes after this method has been called and you still need to call decoded_content() if you want to process its content as a string. =item $mess->encode( $encoding, ... ) Apply the given encodings to the content of the message. Returns TRUE if successful. The "identity" (non-)encoding is always supported; other currently supported encodings, subject to availability of required additional modules, are "gzip", "deflate", "x-bzip2", "base64" and "br". A successful call to this function will set the C header. Note that C or C messages can't be encoded and this method will croak if you try. =item $mess->parts =item $mess->parts( @parts ) =item $mess->parts( \@parts ) Messages can be composite, i.e. contain other messages. The composite messages have a content type of C or C. This method give access to the contained messages. The argumentless form will return a list of C objects. If the content type of $msg is not C or C then this will return the empty list. In scalar context only the first object is returned. The returned message parts should be regarded as read-only (future versions of this library might make it possible to modify the parent by modifying the parts). If the content type of $msg is C then there will only be one part returned. If the content type is C, then the return value will be either an C or an C object. If a @parts argument is given, then the content of the message will be modified. The array reference form is provided so that an empty list can be provided. The @parts array should contain C objects. The @parts objects are owned by $mess after this call and should not be modified or made part of other messages. When updating the message with this method and the old content type of $mess is not C or C, then the content type is set to C and all other content headers are cleared. This method will croak if the content type is C and more than one part is provided. =item $mess->add_part( $part ) This will add a part to a message. The $part argument should be another C object. If the previous content type of $mess is not C then the old content (together with all content headers) will be made part #1 and the content type made C before the new part is added. The $part object is owned by $mess after this call and should not be modified or made part of other messages. There is no return value. =item $mess->clear Will clear the headers and set the content to the empty string. There is no return value =item $mess->protocol =item $mess->protocol( $proto ) Sets the HTTP protocol used for the message. The protocol() is a string like C or C. =item $mess->clone Returns a copy of the message object. =item $mess->as_string =item $mess->as_string( $eol ) Returns the message formatted as a single string. The optional $eol parameter specifies the line ending sequence to use. The default is "\n". If no $eol is given then as_string will ensure that the returned string is newline terminated (even when the message content is not). No extra newline is appended if an explicit $eol is passed. =item $mess->dump( %opt ) Returns the message formatted as a string. In void context print the string. This differs from C<< $mess->as_string >> in that it escapes the bytes of the content so that it's safe to print them and it limits how much content to print. The escapes syntax used is the same as for Perl's double quoted strings. If there is no content the string "(no content)" is shown in its place. Options to influence the output can be passed as key/value pairs. The following options are recognized: =over =item maxlength => $num How much of the content to show. The default is 512. Set this to 0 for unlimited. If the content is longer then the string is chopped at the limit and the string "...\n(### more bytes not shown)" appended. =item no_content => $str Replaces the "(no content)" marker. =item prefix => $str A string that will be prefixed to each line of the dump. =back =back All methods unknown to C itself are delegated to the C object that is part of every message. This allows convenient access to these methods. Refer to L for details of these methods: $mess->header( $field => $val ) $mess->push_header( $field => $val ) $mess->init_header( $field => $val ) $mess->remove_header( $field ) $mess->remove_content_headers $mess->header_field_names $mess->scan( \&doit ) $mess->date $mess->expires $mess->if_modified_since $mess->if_unmodified_since $mess->last_modified $mess->content_type $mess->content_encoding $mess->content_length $mess->content_language $mess->title $mess->user_agent $mess->server $mess->from $mess->referer $mess->www_authenticate $mess->authorization $mess->proxy_authorization $mess->authorization_basic $mess->proxy_authorization_basic =head1 AUTHOR Gisle Aas =head1 COPYRIGHT AND LICENSE This software is copyright (c) 1994 by Gisle Aas. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. =cut __END__ #ABSTRACT: HTTP style message (base class) lib/perl5/vendor_perl/5.42.0/HTTP/PaxHeader/Request.pm000444 000000 000000 00000000025 15210655656 022543 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/HTTP/Request.pm000444 000000 000000 00000021661 15210655656 020603 0ustar00rootwheel000000 000000 package HTTP::Request; use strict; use warnings; our $VERSION = '7.02'; use parent 'HTTP::Message'; sub new { my($class, $method, $uri, $header, $content) = @_; my $self = $class->SUPER::new($header, $content); $self->method($method); $self->uri($uri); $self; } sub parse { my($class, $str) = @_; Carp::carp('Undefined argument to parse()') if $^W && ! defined $str; my $request_line; if (defined $str && $str =~ s/^(.*)\n//) { $request_line = $1; } else { $request_line = $str; $str = ""; } my $self = $class->SUPER::parse($str); if (defined $request_line) { my($method, $uri, $protocol) = split(' ', $request_line); $self->method($method); $self->uri($uri) if defined($uri); $self->protocol($protocol) if $protocol; } $self; } sub clone { my $self = shift; my $clone = bless $self->SUPER::clone, ref($self); $clone->method($self->method); $clone->uri($self->uri); $clone; } sub method { shift->_elem('_method', @_); } sub uri { my $self = shift; my $old = $self->{'_uri'}; if (@_) { my $uri = shift; if (!defined $uri) { # that's ok } elsif (ref $uri) { Carp::croak("A URI can't be a " . ref($uri) . " reference") if ref($uri) eq 'HASH' or ref($uri) eq 'ARRAY'; Carp::croak("Can't use a " . ref($uri) . " object as a URI") unless $uri->can('scheme') && $uri->can('canonical'); $uri = $uri->clone; unless ($HTTP::URI_CLASS eq "URI") { # Argh!! Hate this... old LWP legacy! eval { local $SIG{__DIE__}; $uri = $uri->abs; }; die $@ if $@ && $@ !~ /Missing base argument/; } } else { $uri = $HTTP::URI_CLASS->new($uri); } $self->{'_uri'} = $uri; delete $self->{'_uri_canonical'}; } $old; } *url = \&uri; # legacy sub uri_canonical { my $self = shift; my $uri = $self->{_uri}; if (defined (my $canon = $self->{_uri_canonical})) { # early bailout if these are the exact same string; # rely on stringification of the URI objects return $canon if $canon eq $uri; } # otherwise we need to refresh the memoized value $self->{_uri_canonical} = $uri->canonical; } sub accept_decodable { my $self = shift; $self->header("Accept-Encoding", scalar($self->decodable)); } sub as_string { my $self = shift; my($eol) = @_; $eol = "\n" unless defined $eol; # method must be at least one char, matching ^[a-zA-Z0-9!#$%&'*+.^_`|~-]+$ my $req_line = (defined $self->method && length $self->method) ? $self->method : "-"; my $uri = $self->uri; $uri = (defined $uri) ? $uri->as_string : "-"; $req_line .= " $uri"; my $proto = $self->protocol; $req_line .= " $proto" if $proto; return join($eol, $req_line, $self->SUPER::as_string($eol)); } sub dump { my $self = shift; my @pre = ((defined $self->method && length $self->method) ? $self->method : "-", (defined $self->uri) ? $self->uri : "-"); if (my $prot = $self->protocol) { push(@pre, $prot); } return $self->SUPER::dump( preheader => join(" ", @pre), @_, ); } 1; =pod =encoding UTF-8 =head1 NAME HTTP::Request - HTTP style request message =head1 VERSION version 7.02 =head1 SYNOPSIS require HTTP::Request; $request = HTTP::Request->new(GET => 'http://www.example.com/'); and usually used like this: $ua = LWP::UserAgent->new; $response = $ua->request($request); =head1 DESCRIPTION C is a class encapsulating HTTP style requests, consisting of a request line, some headers, and a content body. Note that the LWP library uses HTTP style requests even for non-HTTP protocols. Instances of this class are usually passed to the request() method of an C object. C is a subclass of C and therefore inherits its methods. The following additional methods are available: =over 4 =item $r = HTTP::Request->new( $method, $uri ) =item $r = HTTP::Request->new( $method, $uri, $header ) =item $r = HTTP::Request->new( $method, $uri, $header, $content ) Constructs a new C object describing a request on the object $uri using method $method. The $method argument must be a string. The $uri argument can be either a string, or a reference to a C object. The optional $header argument should be a reference to an C object or a plain array reference of key/value pairs. The optional $content argument should be a string of bytes. =item $r = HTTP::Request->parse( $str ) This constructs a new request object by parsing the given string. =item $r->method =item $r->method( $val ) This is used to get/set the method attribute. The method should be a short string like "GET", "HEAD", "PUT", "PATCH" or "POST". =item $r->uri =item $r->uri( $val ) This is used to get/set the uri attribute. The $val can be a reference to a URI object or a plain string. If a string is given, then it should be parsable as an absolute URI. =item $r->header( $field ) =item $r->header( $field => $value ) This is used to get/set header values and it is inherited from C via C. See L for details and other similar methods that can be used to access the headers. =item $r->accept_decodable This will set the C header to the list of encodings that decoded_content() can decode. =item $r->content =item $r->content( $bytes ) This is used to get/set the content and it is inherited from the C base class. See L for details and other methods that can be used to access the content. Note that the content should be a string of bytes. Strings in perl can contain characters outside the range of a byte. The C module can be used to turn such strings into a string of bytes. =item $r->as_string =item $r->as_string( $eol ) Method returning a textual representation of the request. =back =head1 EXAMPLES Creating requests to be sent with L or others can be easy. Here are a few examples. =head2 Simple POST Here, we'll create a simple POST request that could be used to send JSON data to an endpoint. #!/usr/bin/env perl use strict; use warnings; use HTTP::Request (); use JSON::MaybeXS qw(encode_json); my $url = 'https://www.example.com/api/user/123'; my $header = ['Content-Type' => 'application/json; charset=UTF-8']; my $data = {foo => 'bar', baz => 'quux'}; my $encoded_data = encode_json($data); my $r = HTTP::Request->new('POST', $url, $header, $encoded_data); # at this point, we could send it via LWP::UserAgent # my $ua = LWP::UserAgent->new(); # my $res = $ua->request($r); =head2 Batch POST Request Some services, like Google, allow multiple requests to be sent in one batch. L for example. Using the C method from L makes this simple. #!/usr/bin/env perl use strict; use warnings; use HTTP::Request (); use JSON::MaybeXS qw(encode_json); my $auth_token = 'auth_token'; my $batch_url = 'https://www.googleapis.com/batch'; my $url = 'https://www.googleapis.com/drive/v3/files/fileId/permissions?fields=id'; my $url_no_email = 'https://www.googleapis.com/drive/v3/files/fileId/permissions?fields=id&sendNotificationEmail=false'; # generate a JSON post request for one of the batch entries my $req1 = build_json_request($url, { emailAddress => 'example@appsrocks.com', role => "writer", type => "user", }); # generate a JSON post request for one of the batch entries my $req2 = build_json_request($url_no_email, { domain => "appsrocks.com", role => "reader", type => "domain", }); # generate a multipart request to send all of the other requests my $r = HTTP::Request->new('POST', $batch_url, [ 'Accept-Encoding' => 'gzip', # if we don't provide a boundary here, HTTP::Message will generate # one for us. We could use UUID::uuid() here if we wanted. 'Content-Type' => 'multipart/mixed; boundary=END_OF_PART' ]); # add the two POST requests to the main request $r->add_part($req1, $req2); # at this point, we could send it via LWP::UserAgent # my $ua = LWP::UserAgent->new(); # my $res = $ua->request($r); exit(); sub build_json_request { my ($url, $href) = @_; my $header = ['Authorization' => "Bearer $auth_token", 'Content-Type' => 'application/json; charset=UTF-8']; return HTTP::Request->new('POST', $url, $header, encode_json($href)); } =head1 SEE ALSO L, L, L, L =head1 AUTHOR Gisle Aas =head1 COPYRIGHT AND LICENSE This software is copyright (c) 1994 by Gisle Aas. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. =cut __END__ #ABSTRACT: HTTP style request message lib/perl5/vendor_perl/5.42.0/HTTP/Request/PaxHeader/Common.pm000444 000000 000000 00000000025 15210655656 023773 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/HTTP/Request/Common.pm000444 000000 000000 00000037553 15210655656 022042 0ustar00rootwheel000000 000000 package HTTP::Request::Common; use strict; use warnings; our $VERSION = '7.02'; our $DYNAMIC_FILE_UPLOAD ||= 0; # make it defined (don't know why) our $READ_BUFFER_SIZE = 8192; use Exporter 5.57 'import'; our @EXPORT =qw(GET HEAD PUT PATCH POST OPTIONS); our @EXPORT_OK = qw($DYNAMIC_FILE_UPLOAD DELETE); require HTTP::Request; use Carp(); use File::Spec; my $CRLF = "\015\012"; # "\r\n" is not portable sub GET { _simple_req('GET', @_); } sub HEAD { _simple_req('HEAD', @_); } sub DELETE { _simple_req('DELETE', @_); } sub PATCH { request_type_with_data('PATCH', @_); } sub POST { request_type_with_data('POST', @_); } sub PUT { request_type_with_data('PUT', @_); } sub OPTIONS { request_type_with_data('OPTIONS', @_); } sub request_type_with_data { my $type = shift; my $url = shift; my $req = HTTP::Request->new($type => $url); my $content; $content = shift if @_ and ref $_[0]; my($k, $v); while (($k,$v) = splice(@_, 0, 2)) { if (lc($k) eq 'content') { $content = $v; } else { $req->push_header($k, $v); } } my $ct = $req->header('Content-Type'); unless ($ct) { $ct = 'application/x-www-form-urlencoded'; } elsif ($ct eq 'form-data') { $ct = 'multipart/form-data'; } if (ref $content) { if ($ct =~ m,^multipart/form-data\s*(;|$),i) { require HTTP::Headers::Util; my @v = HTTP::Headers::Util::split_header_words($ct); Carp::carp("Multiple Content-Type headers") if @v > 1; @v = @{$v[0]}; my $boundary; my $boundary_index; for (my @tmp = @v; @tmp;) { my($k, $v) = splice(@tmp, 0, 2); if ($k eq "boundary") { $boundary = $v; $boundary_index = @v - @tmp - 1; last; } } ($content, $boundary) = form_data($content, $boundary, $req); if ($boundary_index) { $v[$boundary_index] = $boundary; } else { push(@v, boundary => $boundary); } $ct = HTTP::Headers::Util::join_header_words(@v); } else { # We use a temporary URI object to format # the application/x-www-form-urlencoded content. require URI; my $url = URI->new('http:'); $url->query_form(ref($content) eq "HASH" ? %$content : @$content); $content = $url->query; } } $req->header('Content-Type' => $ct); # might be redundant if (defined($content)) { $req->header('Content-Length' => length($content)) unless ref($content); $req->content($content); } else { $req->header('Content-Length' => 0); } $req; } sub _simple_req { my($method, $url) = splice(@_, 0, 2); my $req = HTTP::Request->new($method => $url); my($k, $v); my $content; while (($k,$v) = splice(@_, 0, 2)) { if (lc($k) eq 'content') { $req->add_content($v); $content++; } else { $req->push_header($k, $v); } } if ($content && !defined($req->header("Content-Length"))) { $req->header("Content-Length", length(${$req->content_ref})); } $req; } sub form_data # RFC1867 { my($data, $boundary, $req) = @_; my @data = ref($data) eq "HASH" ? %$data : @$data; # copy my $fhparts; my @parts; while (my ($k,$v) = splice(@data, 0, 2)) { if (!ref($v)) { $k =~ s/([\\\"])/\\$1/g; # escape quotes and backslashes no warnings 'uninitialized'; push(@parts, qq(Content-Disposition: form-data; name="$k"$CRLF$CRLF$v)); } else { my($file, $usename, @headers) = @$v; unless (defined $usename) { $usename = $file; $usename = (File::Spec->splitpath($usename))[-1] if defined($usename); } $k =~ s/([\\\"])/\\$1/g; my $disp = qq(form-data; name="$k"); if (defined($usename) and length($usename)) { $usename =~ s/([\\\"])/\\$1/g; $disp .= qq(; filename="$usename"); } my $content = ""; my $h = HTTP::Headers->new(@headers); if ($file) { open(my $fh, "<", $file) or Carp::croak("Can't open file $file: $!"); binmode($fh); if ($DYNAMIC_FILE_UPLOAD) { # will read file later, close it now in order to # not accumulate to many open file handles close($fh); $content = \$file; } else { local($/) = undef; # slurp files $content = <$fh>; close($fh); } unless ($h->header("Content-Type")) { require LWP::MediaTypes; LWP::MediaTypes::guess_media_type($file, $h); } } if ($h->header("Content-Disposition")) { # just to get it sorted first $disp = $h->header("Content-Disposition"); $h->remove_header("Content-Disposition"); } if ($h->header("Content")) { $content = $h->header("Content"); $h->remove_header("Content"); } my $head = join($CRLF, "Content-Disposition: $disp", $h->as_string($CRLF), ""); if (ref $content) { push(@parts, [$head, $$content]); $fhparts++; } else { push(@parts, $head . $content); } } } return ("", "none") unless @parts; my $content; if ($fhparts) { $boundary = boundary(10) # hopefully enough randomness unless $boundary; # add the boundaries to the @parts array for (1..@parts-1) { splice(@parts, $_*2-1, 0, "$CRLF--$boundary$CRLF"); } unshift(@parts, "--$boundary$CRLF"); push(@parts, "$CRLF--$boundary--$CRLF"); # See if we can generate Content-Length header my $length = 0; for (@parts) { if (ref $_) { my ($head, $f) = @$_; my $file_size; unless ( -f $f && ($file_size = -s _) ) { # The file is either a dynamic file like /dev/audio # or perhaps a file in the /proc file system where # stat may return a 0 size even though reading it # will produce data. So we cannot make # a Content-Length header. undef $length; last; } $length += $file_size + length $head; } else { $length += length; } } $length && $req->header('Content-Length' => $length); # set up a closure that will return content piecemeal $content = sub { for (;;) { unless (@parts) { defined $length && $length != 0 && Carp::croak "length of data sent did not match calculated Content-Length header. Probably because uploaded file changed in size during transfer."; return; } my $p = shift @parts; unless (ref $p) { $p .= shift @parts while @parts && !ref($parts[0]); defined $length && ($length -= length $p); return $p; } my($buf, $fh) = @$p; unless (ref($fh)) { my $file = $fh; undef($fh); open($fh, "<", $file) || Carp::croak("Can't open file $file: $!"); binmode($fh); } my $buflength = length $buf; my $n = read($fh, $buf, $READ_BUFFER_SIZE, $buflength); if ($n) { $buflength += $n; unshift(@parts, ["", $fh]); } else { close($fh); } if ($buflength) { defined $length && ($length -= $buflength); return $buf } } }; } else { $boundary = boundary() unless $boundary; my $bno = 0; CHECK_BOUNDARY: { for (@parts) { if (index($_, $boundary) >= 0) { # must have a better boundary $boundary = boundary(++$bno); redo CHECK_BOUNDARY; } } last; } $content = "--$boundary$CRLF" . join("$CRLF--$boundary$CRLF", @parts) . "$CRLF--$boundary--$CRLF"; } wantarray ? ($content, $boundary) : $content; } sub boundary { my $size = shift || return "xYzZY"; require MIME::Base64; my $b = MIME::Base64::encode(join("", map chr(rand(256)), 1..$size*3), ""); $b =~ s/[\W]/X/g; # ensure alnum only $b; } 1; =pod =encoding UTF-8 =head1 NAME HTTP::Request::Common - Construct common HTTP::Request objects =head1 VERSION version 7.02 =head1 SYNOPSIS use HTTP::Request::Common; $ua = LWP::UserAgent->new; $ua->request(GET 'http://www.sn.no/'); $ua->request(POST 'http://somewhere/foo', foo => bar, bar => foo); $ua->request(PATCH 'http://somewhere/foo', foo => bar, bar => foo); $ua->request(PUT 'http://somewhere/foo', foo => bar, bar => foo); $ua->request(OPTIONS 'http://somewhere/foo', foo => bar, bar => foo); =head1 DESCRIPTION This module provides functions that return newly created C objects. These functions are usually more convenient to use than the standard C constructor for the most common requests. Note that L has several convenience methods, including C, C, C, C and C. The following functions are provided: =over 4 =item GET $url =item GET $url, Header => Value,... The C function returns an L object initialized with the "GET" method and the specified URL. It is roughly equivalent to the following call HTTP::Request->new( GET => $url, HTTP::Headers->new(Header => Value,...), ) but is less cluttered. What is different is that a header named C will initialize the content part of the request instead of setting a header field. Note that GET requests should normally not have a content, so this hack makes more sense for the C, C and C functions described below. The C method of L exists as a shortcut for C<< $ua->request(GET ...) >>. =item HEAD $url =item HEAD $url, Header => Value,... Like GET() but the method in the request is "HEAD". The C method of L exists as a shortcut for C<< $ua->request(HEAD ...) >>. =item DELETE $url =item DELETE $url, Header => Value,... Like C but the method in the request is C. This function is not exported by default. =item PATCH $url =item PATCH $url, Header => Value,... =item PATCH $url, $form_ref, Header => Value,... =item PATCH $url, Header => Value,..., Content => $form_ref =item PATCH $url, Header => Value,..., Content => $content The same as C below, but the method in the request is C. =item PUT $url =item PUT $url, Header => Value,... =item PUT $url, $form_ref, Header => Value,... =item PUT $url, Header => Value,..., Content => $form_ref =item PUT $url, Header => Value,..., Content => $content The same as C below, but the method in the request is C =item OPTIONS $url =item OPTIONS $url, Header => Value,... =item OPTIONS $url, $form_ref, Header => Value,... =item OPTIONS $url, Header => Value,..., Content => $form_ref =item OPTIONS $url, Header => Value,..., Content => $content The same as C below, but the method in the request is C This was added in version 6.21, so you should require that in your code: use HTTP::Request::Common 6.21; =item POST $url =item POST $url, Header => Value,... =item POST $url, $form_ref, Header => Value,... =item POST $url, Header => Value,..., Content => $form_ref =item POST $url, Header => Value,..., Content => $content C, C and C all work with the same parameters. %data = ( title => 'something', body => something else' ); $ua = LWP::UserAgent->new(); $request = HTTP::Request::Common::POST( $url, [ %data ] ); $response = $ua->request($request); They take a second optional array or hash reference parameter C<$form_ref>. The content can also be specified directly using the C pseudo-header, and you may also provide the C<$form_ref> this way. The C pseudo-header steals a bit of the header field namespace as there is no way to directly specify a header that is actually called "Content". If you really need this you must update the request returned in a separate statement. The C<$form_ref> argument can be used to pass key/value pairs for the form content. By default we will initialize a request using the C content type. This means that you can emulate an HTML Eform> POSTing like this: POST 'http://www.perl.org/survey.cgi', [ name => 'Gisle Aas', email => 'gisle@aas.no', gender => 'M', born => '1964', perc => '3%', ]; This will create an L object that looks like this: POST http://www.perl.org/survey.cgi Content-Length: 66 Content-Type: application/x-www-form-urlencoded name=Gisle%20Aas&email=gisle%40aas.no&gender=M&born=1964&perc=3%25 Multivalued form fields can be specified by either repeating the field name or by passing the value as an array reference. The POST method also supports the C content used for I as specified in RFC 1867. You trigger this content format by specifying a content type of C<'form-data'> as one of the request headers. If one of the values in the C<$form_ref> is an array reference, then it is treated as a file part specification with the following interpretation: [ $file, $filename, Header => Value... ] [ undef, $filename, Header => Value,..., Content => $content ] The first value in the array ($file) is the name of a file to open. This file will be read and its content placed in the request. The routine will croak if the file can't be opened. Use an C as $file value if you want to specify the content directly with a C header. The $filename is the filename to report in the request. If this value is undefined, then the basename of the $file will be used. You can specify an empty string as $filename if you want to suppress sending the filename when you provide a $file value. If a $file is provided by no C header, then C and C will be filled in automatically with the values returned by C Sending my F<~/.profile> to the survey used as example above can be achieved by this: POST 'http://www.perl.org/survey.cgi', Content_Type => 'form-data', Content => [ name => 'Gisle Aas', email => 'gisle@aas.no', gender => 'M', born => '1964', init => ["$ENV{HOME}/.profile"], ] This will create an L object that almost looks this (the boundary and the content of your F<~/.profile> is likely to be different): POST http://www.perl.org/survey.cgi Content-Length: 388 Content-Type: multipart/form-data; boundary="6G+f" --6G+f Content-Disposition: form-data; name="name" Gisle Aas --6G+f Content-Disposition: form-data; name="email" gisle@aas.no --6G+f Content-Disposition: form-data; name="gender" M --6G+f Content-Disposition: form-data; name="born" 1964 --6G+f Content-Disposition: form-data; name="init"; filename=".profile" Content-Type: text/plain PATH=/local/perl/bin:$PATH export PATH --6G+f-- If you set the C<$DYNAMIC_FILE_UPLOAD> variable (exportable) to some TRUE value, then you get back a request object with a subroutine closure as the content attribute. This subroutine will read the content of any files on demand and return it in suitable chunks. This allow you to upload arbitrary big files without using lots of memory. You can even upload infinite files like F if you wish; however, if the file is not a plain file, there will be no C header defined for the request. Not all servers (or server applications) like this. Also, if the file(s) change in size between the time the C is calculated and the time that the last chunk is delivered, the subroutine will C. The C method of L exists as a shortcut for C<< $ua->request(POST ...) >>. =back =head1 SEE ALSO L, L Also, there are some examples in L that you might find useful. For example, batch requests are explained there. =head1 AUTHOR Gisle Aas =head1 COPYRIGHT AND LICENSE This software is copyright (c) 1994 by Gisle Aas. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. =cut __END__ #ABSTRACT: Construct common HTTP::Request objects lib/perl5/vendor_perl/5.42.0/HTTP/PaxHeader/Response.pm000444 000000 000000 00000000025 15210655656 022711 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/HTTP/Response.pm000444 000000 000000 00000041426 15210655656 020752 0ustar00rootwheel000000 000000 package HTTP::Response; use strict; use warnings; our $VERSION = '7.02'; use parent 'HTTP::Message'; use HTTP::Status (); sub new { my($class, $rc, $msg, $header, $content) = @_; my $self = $class->SUPER::new($header, $content); $self->code($rc); $self->message($msg); $self; } sub parse { my($class, $str) = @_; Carp::carp('Undefined argument to parse()') if $^W && ! defined $str; my $status_line; if (defined $str && $str =~ s/^(.*)\n//) { $status_line = $1; } else { $status_line = $str; $str = ""; } $status_line =~ s/\r\z// if defined $status_line; my $self = $class->SUPER::parse($str); if (defined $status_line) { my($protocol, $code, $message); if ($status_line =~ /^\d{3} /) { # Looks like a response created by HTTP::Response->new ($code, $message) = split(' ', $status_line, 2); } else { ($protocol, $code, $message) = split(' ', $status_line, 3); } $self->protocol($protocol) if $protocol; $self->code($code) if defined($code); $self->message($message) if defined($message); } $self; } sub clone { my $self = shift; my $clone = bless $self->SUPER::clone, ref($self); $clone->code($self->code); $clone->message($self->message); $clone->request($self->request->clone) if $self->request; # we don't clone previous $clone; } sub code { shift->_elem('_rc', @_); } sub message { shift->_elem('_msg', @_); } sub previous { shift->_elem('_previous',@_); } sub request { shift->_elem('_request', @_); } sub status_line { my $self = shift; my $code = $self->{'_rc'} || "000"; my $mess = $self->{'_msg'} || HTTP::Status::status_message($code) || "Unknown code"; return "$code $mess"; } sub base { my $self = shift; my $base = ( $self->header('Content-Base'), # used to be HTTP/1.1 $self->header('Base'), # HTTP/1.0 )[0]; if ($base && $base =~ /^$URI::scheme_re:/o) { # already absolute return $HTTP::URI_CLASS->new($base); } my $req = $self->request; if ($req) { # if $base is undef here, the return value is effectively # just a copy of $self->request->uri. return $HTTP::URI_CLASS->new_abs($base, $req->uri); } # can't find an absolute base return undef; } sub redirects { my $self = shift; my @r; my $r = $self; while (my $p = $r->previous) { push(@r, $p); $r = $p; } return @r unless wantarray; return reverse @r; } sub filename { my $self = shift; my $file; my $cd = $self->header('Content-Disposition'); if ($cd) { require HTTP::Headers::Util; if (my @cd = HTTP::Headers::Util::split_header_words($cd)) { my ($disposition, undef, %cd_param) = @{$cd[-1]}; $file = $cd_param{filename}; # RFC 2047 encoded? if ($file && $file =~ /^=\?(.+?)\?(.+?)\?(.+)\?=$/) { my $charset = $1; my $encoding = uc($2); my $encfile = $3; if ($encoding eq 'Q' || $encoding eq 'B') { local($SIG{__DIE__}); eval { if ($encoding eq 'Q') { $encfile =~ s/_/ /g; require MIME::QuotedPrint; $encfile = MIME::QuotedPrint::decode($encfile); } else { # $encoding eq 'B' require MIME::Base64; $encfile = MIME::Base64::decode($encfile); } require Encode; require Encode::Locale; Encode::from_to($encfile, $charset, "locale_fs"); }; $file = $encfile unless $@; } } } } unless (defined($file) && length($file)) { my $uri; if (my $cl = $self->header('Content-Location')) { $uri = URI->new($cl); } elsif (my $request = $self->request) { $uri = $request->uri; } if ($uri) { $file = ($uri->path_segments)[-1]; } } if ($file) { $file =~ s,.*[\\/],,; # basename } if ($file && !length($file)) { $file = undef; } $file; } sub as_string { my $self = shift; my($eol) = @_; $eol = "\n" unless defined $eol; my $status_line = $self->status_line; my $proto = $self->protocol; $status_line = "$proto $status_line" if $proto; return join($eol, $status_line, $self->SUPER::as_string($eol)); } sub dump { my $self = shift; my $status_line = $self->status_line; my $proto = $self->protocol; $status_line = "$proto $status_line" if $proto; return $self->SUPER::dump( preheader => $status_line, @_, ); } sub is_info { HTTP::Status::is_info (shift->{'_rc'}); } sub is_success { HTTP::Status::is_success (shift->{'_rc'}); } sub is_redirect { HTTP::Status::is_redirect (shift->{'_rc'}); } sub is_error { HTTP::Status::is_error (shift->{'_rc'}); } sub is_client_error { HTTP::Status::is_client_error (shift->{'_rc'}); } sub is_server_error { HTTP::Status::is_server_error (shift->{'_rc'}); } sub error_as_HTML { my $self = shift; my $title = 'An Error Occurred'; my $body = $self->status_line; $body =~ s/&/&/g; $body =~ s/ $title

$title

$body

EOM } sub current_age { my $self = shift; my $time = shift; # Implementation of RFC 2616 section 13.2.3 # (age calculations) my $response_time = $self->client_date; my $date = $self->date; my $age = 0; if ($response_time && $date) { $age = $response_time - $date; # apparent_age $age = 0 if $age < 0; } my $age_v = $self->header('Age'); if ($age_v && $age_v > $age) { $age = $age_v; # corrected_received_age } if ($response_time) { my $request = $self->request; if ($request) { my $request_time = $request->date; if ($request_time && $request_time < $response_time) { # Add response_delay to age to get 'corrected_initial_age' $age += $response_time - $request_time; } } $age += ($time || time) - $response_time; } return $age; } sub freshness_lifetime { my($self, %opt) = @_; # First look for the Cache-Control: max-age=n header for my $cc ($self->header('Cache-Control')) { for my $cc_dir (split(/\s*,\s*/, $cc)) { return $1 if $cc_dir =~ /^max-age\s*=\s*(\d+)/i; } } # Next possibility is to look at the "Expires" header my $date = $self->date || $self->client_date || $opt{time} || time; if (my $expires = $self->expires) { return $expires - $date; } # Must apply heuristic expiration return undef if exists $opt{heuristic_expiry} && !$opt{heuristic_expiry}; # Default heuristic expiration parameters $opt{h_min} ||= 60; $opt{h_max} ||= 24 * 3600; $opt{h_lastmod_fraction} ||= 0.10; # 10% since last-mod suggested by RFC2616 $opt{h_default} ||= 3600; # Should give a warning if more than 24 hours according to # RFC 2616 section 13.2.4. Here we just make this the default # maximum value. if (my $last_modified = $self->last_modified) { my $h_exp = ($date - $last_modified) * $opt{h_lastmod_fraction}; return $opt{h_min} if $h_exp < $opt{h_min}; return $opt{h_max} if $h_exp > $opt{h_max}; return $h_exp; } # default when all else fails return $opt{h_min} if $opt{h_min} > $opt{h_default}; return $opt{h_default}; } sub is_fresh { my($self, %opt) = @_; $opt{time} ||= time; my $f = $self->freshness_lifetime(%opt); return undef unless defined($f); return $f > $self->current_age($opt{time}); } sub fresh_until { my($self, %opt) = @_; $opt{time} ||= time; my $f = $self->freshness_lifetime(%opt); return undef unless defined($f); return $f - $self->current_age($opt{time}) + $opt{time}; } 1; =pod =encoding UTF-8 =head1 NAME HTTP::Response - HTTP style response message =head1 VERSION version 7.02 =head1 SYNOPSIS Response objects are returned by the request() method of the C: # ... $response = $ua->request($request); if ($response->is_success) { print $response->decoded_content; } else { print STDERR $response->status_line, "\n"; } =head1 DESCRIPTION The C class encapsulates HTTP style responses. A response consists of a response line, some headers, and a content body. Note that the LWP library uses HTTP style responses even for non-HTTP protocol schemes. Instances of this class are usually created and returned by the request() method of an C object. C is a subclass of C and therefore inherits its methods. The following additional methods are available: =over 4 =item $r = HTTP::Response->new( $code ) =item $r = HTTP::Response->new( $code, $msg ) =item $r = HTTP::Response->new( $code, $msg, $header ) =item $r = HTTP::Response->new( $code, $msg, $header, $content ) Constructs a new C object describing a response with response code $code and optional message $msg. The optional $header argument should be a reference to an C object or a plain array reference of key/value pairs. The optional $content argument should be a string of bytes. The meanings of these arguments are described below. =item $r = HTTP::Response->parse( $str ) This constructs a new response object by parsing the given string. =item $r->code =item $r->code( $code ) This is used to get/set the code attribute. The code is a 3 digit number that encode the overall outcome of an HTTP response. The C module provide constants that provide mnemonic names for the code attribute. =item $r->message =item $r->message( $message ) This is used to get/set the message attribute. The message is a short human readable single line string that explains the response code. =item $r->header( $field ) =item $r->header( $field => $value ) This is used to get/set header values and it is inherited from C via C. See L for details and other similar methods that can be used to access the headers. =item $r->content =item $r->content( $bytes ) This is used to get/set the raw content and it is inherited from the C base class. See L for details and other methods that can be used to access the content. =item $r->decoded_content( %options ) This will return the content after any C and charsets have been decoded. See L for details. =item $r->request =item $r->request( $request ) This is used to get/set the request attribute. The request attribute is a reference to the request that caused this response. It does not have to be the same request passed to the $ua->request() method, because there might have been redirects and authorization retries in between. =item $r->previous =item $r->previous( $response ) This is used to get/set the previous attribute. The previous attribute is used to link together chains of responses. You get chains of responses if the first response is redirect or unauthorized. The value is C if this is the first response in a chain. Note that the method $r->redirects is provided as a more convenient way to access the response chain. =item $r->status_line Returns the string "Ecode> Emessage>". If the message attribute is not set then the official name of Ecode> (see L) is substituted. =item $r->base Returns the base URI for this response. The return value will be a reference to a URI object. The base URI is obtained from one the following sources (in priority order): =over 4 =item 1. Embedded in the document content, for instance in HTML documents. =item 2. A "Content-Base:" header in the response. For backwards compatibility with older HTTP implementations we will also look for the "Base:" header. =item 3. The URI used to request this response. This might not be the original URI that was passed to $ua->request() method, because we might have received some redirect responses first. =back If none of these sources provide an absolute URI, undef is returned. B: previous versions of HTTP::Response would also consider a "Content-Location:" header, as L said it should be. But this was never widely implemented by browsers, and now L says it should no longer be considered. When the LWP protocol modules produce the HTTP::Response object, then any base URI embedded in the document (step 1) will already have initialized the "Content-Base:" header. (See L). This means that this method only performs the last 2 steps (the content is not always available either). =item $r->filename Returns a filename for this response. Note that doing sanity checks on the returned filename (eg. removing characters that cannot be used on the target filesystem where the filename would be used, and laundering it for security purposes) are the caller's responsibility; the only related thing done by this method is that it makes a simple attempt to return a plain filename with no preceding path segments. The filename is obtained from one the following sources (in priority order): =over 4 =item 1. A "Content-Disposition:" header in the response. Proper decoding of RFC 2047 encoded filenames requires the C (for "Q" encoding), C (for "B" encoding), and C modules. =item 2. A "Content-Location:" header in the response. =item 3. The URI used to request this response. This might not be the original URI that was passed to $ua->request() method, because we might have received some redirect responses first. =back If a filename cannot be derived from any of these sources, undef is returned. =item $r->as_string =item $r->as_string( $eol ) Returns a textual representation of the response. =item $r->is_info =item $r->is_success =item $r->is_redirect =item $r->is_error =item $r->is_client_error =item $r->is_server_error These methods indicate if the response was informational, successful, a redirection, or an error. See L for the meaning of these. =item $r->error_as_HTML Returns a string containing a complete HTML document indicating what error occurred. This method should only be called when $r->is_error is TRUE. =item $r->redirects Returns the list of redirect responses that lead up to this response by following the $r->previous chain. The list order is oldest first. In scalar context return the number of redirect responses leading up to this one. =item $r->current_age Calculates the "current age" of the response as specified by RFC 2616 section 13.2.3. The age of a response is the time since it was sent by the origin server. The returned value is a number representing the age in seconds. =item $r->freshness_lifetime( %opt ) Calculates the "freshness lifetime" of the response as specified by RFC 2616 section 13.2.4. The "freshness lifetime" is the length of time between the generation of a response and its expiration time. The returned value is the number of seconds until expiry. If the response does not contain an "Expires" or a "Cache-Control" header, then this function will apply some simple heuristic based on the "Last-Modified" header to determine a suitable lifetime. The following options might be passed to control the heuristics: =over =item heuristic_expiry => $bool If passed as a FALSE value, don't apply heuristics and just return C when "Expires" or "Cache-Control" is lacking. =item h_lastmod_fraction => $num This number represent the fraction of the difference since the "Last-Modified" timestamp to make the expiry time. The default is C<0.10>, the suggested typical setting of 10% in RFC 2616. =item h_min => $sec This is the lower limit of the heuristic expiry age to use. The default is C<60> (1 minute). =item h_max => $sec This is the upper limit of the heuristic expiry age to use. The default is C<86400> (24 hours). =item h_default => $sec This is the expiry age to use when nothing else applies. The default is C<3600> (1 hour) or "h_min" if greater. =back =item $r->is_fresh( %opt ) Returns TRUE if the response is fresh, based on the values of freshness_lifetime() and current_age(). If the response is no longer fresh, then it has to be re-fetched or re-validated by the origin server. Options might be passed to control expiry heuristics, see the description of freshness_lifetime(). =item $r->fresh_until( %opt ) Returns the time (seconds since epoch) when this entity is no longer fresh. Options might be passed to control expiry heuristics, see the description of freshness_lifetime(). =back =head1 SEE ALSO L, L, L, L =head1 AUTHOR Gisle Aas =head1 COPYRIGHT AND LICENSE This software is copyright (c) 1994 by Gisle Aas. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. =cut __END__ #ABSTRACT: HTTP style response message lib/perl5/vendor_perl/5.42.0/HTTP/PaxHeader/Status.pm000444 000000 000000 00000000025 15210655656 022376 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/HTTP/Status.pm000444 000000 000000 00000033515 15210655656 020437 0ustar00rootwheel000000 000000 package HTTP::Status; use strict; use warnings; our $VERSION = '7.02'; use Exporter 5.57 'import'; our @EXPORT = qw(is_info is_success is_redirect is_error status_message); our @EXPORT_OK = qw(is_client_error is_server_error is_cacheable_by_default status_constant_name status_codes); # Note also addition of mnemonics to @EXPORT below # Unmarked codes are from RFC 7231 (2017-12-20) # See also: # https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml my %StatusCode = ( 100 => 'Continue', 101 => 'Switching Protocols', 102 => 'Processing', # RFC 2518: WebDAV 103 => 'Early Hints', # RFC 8297: Indicating Hints # 104 .. 199 200 => 'OK', 201 => 'Created', 202 => 'Accepted', 203 => 'Non-Authoritative Information', 204 => 'No Content', 205 => 'Reset Content', 206 => 'Partial Content', # RFC 7233: Range Requests 207 => 'Multi-Status', # RFC 4918: WebDAV 208 => 'Already Reported', # RFC 5842: WebDAV bindings # 209 .. 225 226 => 'IM Used', # RFC 3229: Delta encoding # 227 .. 299 300 => 'Multiple Choices', 301 => 'Moved Permanently', 302 => 'Found', 303 => 'See Other', 304 => 'Not Modified', # RFC 7232: Conditional Request 305 => 'Use Proxy', 306 => '(Unused)', # RFC 9110: Previously used and reserved 307 => 'Temporary Redirect', 308 => 'Permanent Redirect', # RFC 7528: Permanent Redirect # 309 .. 399 400 => 'Bad Request', 401 => 'Unauthorized', # RFC 7235: Authentication 402 => 'Payment Required', 403 => 'Forbidden', 404 => 'Not Found', 405 => 'Method Not Allowed', 406 => 'Not Acceptable', 407 => 'Proxy Authentication Required', # RFC 7235: Authentication 408 => 'Request Timeout', 409 => 'Conflict', 410 => 'Gone', 411 => 'Length Required', 412 => 'Precondition Failed', # RFC 7232: Conditional Request 413 => 'Content Too Large', 414 => 'URI Too Long', 415 => 'Unsupported Media Type', 416 => 'Range Not Satisfiable', # RFC 7233: Range Requests 417 => 'Expectation Failed', 418 => "I'm a teapot", # RFC 2324: RFC9110 reserved it # 419 .. 420 421 => 'Misdirected Request', # RFC 7540: HTTP/2 422 => 'Unprocessable Content', # RFC 9110: WebDAV 423 => 'Locked', # RFC 4918: WebDAV 424 => 'Failed Dependency', # RFC 4918: WebDAV 425 => 'Too Early', # RFC 8470: Using Early Data in HTTP 426 => 'Upgrade Required', # 427 428 => 'Precondition Required', # RFC 6585: Additional Codes 429 => 'Too Many Requests', # RFC 6585: Additional Codes # 430 431 => 'Request Header Fields Too Large', # RFC 6585: Additional Codes # 432 .. 450 451 => 'Unavailable For Legal Reasons', # RFC 7725: Legal Obstacles # 452 .. 499 500 => 'Internal Server Error', 501 => 'Not Implemented', 502 => 'Bad Gateway', 503 => 'Service Unavailable', 504 => 'Gateway Timeout', 505 => 'HTTP Version Not Supported', 506 => 'Variant Also Negotiates', # RFC 2295: Transparent Ngttn 507 => 'Insufficient Storage', # RFC 4918: WebDAV 508 => 'Loop Detected', # RFC 5842: WebDAV bindings # 509 510 => 'Not Extended', # RFC 2774: Extension Framework 511 => 'Network Authentication Required', # RFC 6585: Additional Codes # Keep some unofficial codes that used to be in this distribution 449 => 'Retry with', # microsoft 509 => 'Bandwidth Limit Exceeded', # Apache / cPanel ); my %StatusCodeName; my $mnemonicCode = ''; my ($code, $message); while (($code, $message) = each %StatusCode) { next if $message eq '(Unused)'; # create mnemonic subroutines $message =~ s/I'm/I am/; $message =~ tr/a-z \-/A-Z__/; my $constant_name = "HTTP_".$message; $mnemonicCode .= "sub $constant_name () { $code }\n"; $mnemonicCode .= "*RC_$message = \\&HTTP_$message;\n"; # legacy $mnemonicCode .= "push(\@EXPORT_OK, 'HTTP_$message');\n"; $mnemonicCode .= "push(\@EXPORT, 'RC_$message');\n"; $StatusCodeName{$code} = $constant_name } eval $mnemonicCode; # only one eval for speed die if $@; # backwards compatibility *RC_MOVED_TEMPORARILY = \&RC_FOUND; # 302 was renamed in the standard push(@EXPORT, "RC_MOVED_TEMPORARILY"); my %compat = ( UNPROCESSABLE_ENTITY => \&HTTP_UNPROCESSABLE_CONTENT, PAYLOAD_TOO_LARGE => \&HTTP_CONTENT_TOO_LARGE, REQUEST_ENTITY_TOO_LARGE => \&HTTP_CONTENT_TOO_LARGE, REQUEST_URI_TOO_LARGE => \&HTTP_URI_TOO_LONG, REQUEST_RANGE_NOT_SATISFIABLE => \&HTTP_RANGE_NOT_SATISFIABLE, NO_CODE => \&HTTP_TOO_EARLY, UNORDERED_COLLECTION => \&HTTP_TOO_EARLY, ); foreach my $name (keys %compat) { push(@EXPORT, "RC_$name"); push(@EXPORT_OK, "HTTP_$name"); no strict 'refs'; *{"RC_$name"} = $compat{$name}; *{"HTTP_$name"} = $compat{$name}; } our %EXPORT_TAGS = ( constants => [grep /^HTTP_/, @EXPORT_OK], is => [grep /^is_/, @EXPORT, @EXPORT_OK], ); sub status_message ($) { $StatusCode{$_[0]}; } sub status_constant_name ($) { exists($StatusCodeName{$_[0]}) ? $StatusCodeName{$_[0]} : undef; } sub is_info ($) { $_[0] && $_[0] >= 100 && $_[0] < 200; } sub is_success ($) { $_[0] && $_[0] >= 200 && $_[0] < 300; } sub is_redirect ($) { $_[0] && $_[0] >= 300 && $_[0] < 400; } sub is_error ($) { $_[0] && $_[0] >= 400 && $_[0] < 600; } sub is_client_error ($) { $_[0] && $_[0] >= 400 && $_[0] < 500; } sub is_server_error ($) { $_[0] && $_[0] >= 500 && $_[0] < 600; } sub is_cacheable_by_default ($) { $_[0] && ( $_[0] == 200 # OK || $_[0] == 203 # Non-Authoritative Information || $_[0] == 204 # No Content || $_[0] == 206 # Not Acceptable || $_[0] == 300 # Multiple Choices || $_[0] == 301 # Moved Permanently || $_[0] == 308 # Permanent Redirect || $_[0] == 404 # Not Found || $_[0] == 405 # Method Not Allowed || $_[0] == 410 # Gone || $_[0] == 414 # Request-URI Too Large || $_[0] == 451 # Unavailable For Legal Reasons || $_[0] == 501 # Not Implemented ); } sub status_codes { %StatusCode; } 1; =pod =encoding UTF-8 =head1 NAME HTTP::Status - HTTP Status code processing =head1 VERSION version 7.02 =head1 SYNOPSIS use HTTP::Status qw(:constants :is status_message); if ($rc != HTTP_OK) { print status_message($rc), "\n"; } if (is_success($rc)) { ... } if (is_error($rc)) { ... } if (is_redirect($rc)) { ... } =head1 DESCRIPTION I is a library of routines for defining and classifying HTTP status codes for libwww-perl. Status codes are used to encode the overall outcome of an HTTP response message. Codes correspond to those defined in RFC 2616 and RFC 2518. =head1 CONSTANTS The following constant functions can be used as mnemonic status code names. None of these are exported by default. Use the C<:constants> tag to import them all. HTTP_CONTINUE (100) HTTP_SWITCHING_PROTOCOLS (101) HTTP_PROCESSING (102) HTTP_EARLY_HINTS (103) HTTP_OK (200) HTTP_CREATED (201) HTTP_ACCEPTED (202) HTTP_NON_AUTHORITATIVE_INFORMATION (203) HTTP_NO_CONTENT (204) HTTP_RESET_CONTENT (205) HTTP_PARTIAL_CONTENT (206) HTTP_MULTI_STATUS (207) HTTP_ALREADY_REPORTED (208) HTTP_IM_USED (226) HTTP_MULTIPLE_CHOICES (300) HTTP_MOVED_PERMANENTLY (301) HTTP_FOUND (302) HTTP_SEE_OTHER (303) HTTP_NOT_MODIFIED (304) HTTP_USE_PROXY (305) HTTP_TEMPORARY_REDIRECT (307) HTTP_PERMANENT_REDIRECT (308) HTTP_BAD_REQUEST (400) HTTP_UNAUTHORIZED (401) HTTP_PAYMENT_REQUIRED (402) HTTP_FORBIDDEN (403) HTTP_NOT_FOUND (404) HTTP_METHOD_NOT_ALLOWED (405) HTTP_NOT_ACCEPTABLE (406) HTTP_PROXY_AUTHENTICATION_REQUIRED (407) HTTP_REQUEST_TIMEOUT (408) HTTP_CONFLICT (409) HTTP_GONE (410) HTTP_LENGTH_REQUIRED (411) HTTP_PRECONDITION_FAILED (412) HTTP_CONTENT_TOO_LARGE (413) HTTP_URI_TOO_LONG (414) HTTP_UNSUPPORTED_MEDIA_TYPE (415) HTTP_RANGE_NOT_SATISFIABLE (416) HTTP_EXPECTATION_FAILED (417) HTTP_MISDIRECTED REQUEST (421) HTTP_UNPROCESSABLE_CONTENT (422) HTTP_LOCKED (423) HTTP_FAILED_DEPENDENCY (424) HTTP_TOO_EARLY (425) HTTP_UPGRADE_REQUIRED (426) HTTP_PRECONDITION_REQUIRED (428) HTTP_TOO_MANY_REQUESTS (429) HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE (431) HTTP_UNAVAILABLE_FOR_LEGAL_REASONS (451) HTTP_INTERNAL_SERVER_ERROR (500) HTTP_NOT_IMPLEMENTED (501) HTTP_BAD_GATEWAY (502) HTTP_SERVICE_UNAVAILABLE (503) HTTP_GATEWAY_TIMEOUT (504) HTTP_HTTP_VERSION_NOT_SUPPORTED (505) HTTP_VARIANT_ALSO_NEGOTIATES (506) HTTP_INSUFFICIENT_STORAGE (507) HTTP_LOOP_DETECTED (508) HTTP_NOT_EXTENDED (510) HTTP_NETWORK_AUTHENTICATION_REQUIRED (511) =head1 FUNCTIONS The following additional functions are provided. Most of them are exported by default. The C<:is> import tag can be used to import all the classification functions. =over 4 =item status_message( $code ) The status_message() function will translate status codes to human readable strings. The string is the same as found in the constant names above. For example, C will return C<"Not Found">. If the $code is not registered in the L then C is returned. =item status_constant_name( $code ) The status_constant_name() function will translate a status code to a string which has the name of the constant for that status code. For example, C will return C<"HTTP_NOT_FOUND">. If the C<$code> is not registered in the L then C is returned. =item is_info( $code ) Return TRUE if C<$code> is an I status code (1xx). This class of status code indicates a provisional response which can't have any content. =item is_success( $code ) Return TRUE if C<$code> is a I status code (2xx). =item is_redirect( $code ) Return TRUE if C<$code> is a I status code (3xx). This class of status code indicates that further action needs to be taken by the user agent in order to fulfill the request. =item is_error( $code ) Return TRUE if C<$code> is an I status code (4xx or 5xx). The function returns TRUE for both client and server error status codes. =item is_client_error( $code ) Return TRUE if C<$code> is a I status code (4xx). This class of status code is intended for cases in which the client seems to have erred. This function is B exported by default. =item is_server_error( $code ) Return TRUE if C<$code> is a I status code (5xx). This class of status codes is intended for cases in which the server is aware that it has erred or is incapable of performing the request. This function is B exported by default. =item is_cacheable_by_default( $code ) Return TRUE if C<$code> indicates that a response is cacheable by default, and it can be reused by a cache with heuristic expiration. All other status codes are not cacheable by default. See L. This function is B exported by default. =item status_codes Returns a hash mapping numerical HTTP status code (e.g. 200) to text status messages (e.g. "OK") This function is B exported by default. =back =head1 SEE ALSO L =head1 BUGS For legacy reasons all the C constants are exported by default with the prefix C. It's recommended to use explicit imports and the C<:constants> tag instead of relying on this. =head1 AUTHOR Gisle Aas =head1 COPYRIGHT AND LICENSE This software is copyright (c) 1994 by Gisle Aas. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. =cut __END__ #ABSTRACT: HTTP Status code processing lib/perl5/vendor_perl/5.42.0/powerpc-netbsd-thread-multi/auto/HTTP/Message/PaxHeader/.packlist000644 000000 000000 00000000025 15213024443 032242 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/5.42.0/powerpc-netbsd-thread-multi/auto/HTTP/Message/.packlist000644 000000 000000 00000002172 15213024443 030276 0ustar00rootwheel000000 000000 /usr/pkg/lib/perl5/vendor_perl/5.42.0/HTTP/Config.pm /usr/pkg/lib/perl5/vendor_perl/5.42.0/HTTP/Headers.pm /usr/pkg/lib/perl5/vendor_perl/5.42.0/HTTP/Headers/Auth.pm /usr/pkg/lib/perl5/vendor_perl/5.42.0/HTTP/Headers/ETag.pm /usr/pkg/lib/perl5/vendor_perl/5.42.0/HTTP/Headers/Util.pm /usr/pkg/lib/perl5/vendor_perl/5.42.0/HTTP/Message.pm /usr/pkg/lib/perl5/vendor_perl/5.42.0/HTTP/Request.pm /usr/pkg/lib/perl5/vendor_perl/5.42.0/HTTP/Request/Common.pm /usr/pkg/lib/perl5/vendor_perl/5.42.0/HTTP/Response.pm /usr/pkg/lib/perl5/vendor_perl/5.42.0/HTTP/Status.pm /usr/pkg/lib/perl5/vendor_perl/man/man3/HTTP::Config.3 /usr/pkg/lib/perl5/vendor_perl/man/man3/HTTP::Headers.3 /usr/pkg/lib/perl5/vendor_perl/man/man3/HTTP::Headers::Auth.3 /usr/pkg/lib/perl5/vendor_perl/man/man3/HTTP::Headers::ETag.3 /usr/pkg/lib/perl5/vendor_perl/man/man3/HTTP::Headers::Util.3 /usr/pkg/lib/perl5/vendor_perl/man/man3/HTTP::Message.3 /usr/pkg/lib/perl5/vendor_perl/man/man3/HTTP::Request.3 /usr/pkg/lib/perl5/vendor_perl/man/man3/HTTP::Request::Common.3 /usr/pkg/lib/perl5/vendor_perl/man/man3/HTTP::Response.3 /usr/pkg/lib/perl5/vendor_perl/man/man3/HTTP::Status.3 lib/perl5/vendor_perl/man/man3/PaxHeader/HTTP::Config.3000444 000000 000000 00000000025 15213024436 023023 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/man/man3/HTTP::Config.3000444 000000 000000 00000024635 15213024436 021067 0ustar00rootwheel000000 000000 .\" -*- mode: troff; coding: utf-8 -*- .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45) .\" .\" Standard preamble: .\" ======================================================================== .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. .ie n \{\ . ds C` "" . ds C' "" 'br\} .el\{\ . ds C` . ds C' 'br\} .\" .\" Escape single quotes in literal strings from groff's Unicode transform. .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" .\" If the F register is >0, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .\" .\" Avoid warning from groff about undefined register 'F'. .de IX .. .nr rF 0 .if \n(.g .if rF .nr rF 1 .if (\n(rF:(\n(.g==0)) \{\ . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF .\" .\" Required to disable full justification in groff 1.23.0. .if n .ds AD l .\" ======================================================================== .\" .IX Title "HTTP::Config 3" .TH HTTP::Config 3 2026-06-05 "perl v5.42.2" "User Contributed Perl Documentation" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l .nh .SH NAME HTTP::Config \- Configuration for request and response objects .SH VERSION .IX Header "VERSION" version 7.02 .SH SYNOPSIS .IX Header "SYNOPSIS" .Vb 3 \& use HTTP::Config; \& my $c = HTTP::Config\->new; \& $c\->add(m_domain => ".example.com", m_scheme => "http", verbose => 1); \& \& use HTTP::Request; \& my $request = HTTP::Request\->new(GET => "http://www.example.com"); \& \& if (my @m = $c\->matching($request)) { \& print "Yadayada\en" if $m[0]\->{verbose}; \& } .Ve .SH DESCRIPTION .IX Header "DESCRIPTION" An \f(CW\*(C`HTTP::Config\*(C'\fR object is a list of entries that can be matched against request or request/response pairs. Its purpose is to hold configuration data that can be looked up given a request or response object. .PP Each configuration entry is a hash. Some keys specify matching to occur against attributes of request/response objects. Other keys can be used to hold user data. .PP The following methods are provided: .ie n .IP "$conf = HTTP::Config\->new" 4 .el .IP "\f(CW$conf\fR = HTTP::Config\->new" 4 .IX Item "$conf = HTTP::Config->new" Constructs a new empty \f(CW\*(C`HTTP::Config\*(C'\fR object and returns it. .ie n .IP $conf\->entries 4 .el .IP \f(CW$conf\fR\->entries 4 .IX Item "$conf->entries" Returns the list of entries in the configuration object. In scalar context returns the number of entries. .ie n .IP $conf\->empty 4 .el .IP \f(CW$conf\fR\->empty 4 .IX Item "$conf->empty" Return true if there are no entries in the configuration object. This is just a shorthand for \f(CW\*(C`not $conf\->entries\*(C'\fR. .ie n .IP "$conf\->add( %matchspec, %other )" 4 .el .IP "\f(CW$conf\fR\->add( \f(CW%matchspec\fR, \f(CW%other\fR )" 4 .IX Item "$conf->add( %matchspec, %other )" .PD 0 .ie n .IP "$conf\->add( \e%entry )" 4 .el .IP "\f(CW$conf\fR\->add( \e%entry )" 4 .IX Item "$conf->add( %entry )" .PD Adds a new entry to the configuration. You can either pass separate key/value pairs or a hash reference. .ie n .IP "$conf\->remove( %spec )" 4 .el .IP "\f(CW$conf\fR\->remove( \f(CW%spec\fR )" 4 .IX Item "$conf->remove( %spec )" Removes (and returns) the entries that have matches for all the key/value pairs in \f(CW%spec\fR. If \f(CW%spec\fR is empty this will match all entries; so it will empty the configuration object. .ie n .IP "$conf\->matching( $uri, $request, $response )" 4 .el .IP "\f(CW$conf\fR\->matching( \f(CW$uri\fR, \f(CW$request\fR, \f(CW$response\fR )" 4 .IX Item "$conf->matching( $uri, $request, $response )" .PD 0 .ie n .IP "$conf\->matching( $uri )" 4 .el .IP "\f(CW$conf\fR\->matching( \f(CW$uri\fR )" 4 .IX Item "$conf->matching( $uri )" .ie n .IP "$conf\->matching( $request )" 4 .el .IP "\f(CW$conf\fR\->matching( \f(CW$request\fR )" 4 .IX Item "$conf->matching( $request )" .ie n .IP "$conf\->matching( $response )" 4 .el .IP "\f(CW$conf\fR\->matching( \f(CW$response\fR )" 4 .IX Item "$conf->matching( $response )" .PD Returns the entries that match the given \f(CW$uri\fR, \f(CW$request\fR and \f(CW$response\fR triplet. .Sp If called with a single \f(CW$request\fR object then the \f(CW$uri\fR is obtained by calling its \*(Aquri_canonical\*(Aq method. If called with a single \f(CW$response\fR object, then the request object is obtained by calling its \*(Aqrequest\*(Aq method; and then the \f(CW$uri\fR is obtained as if a single \f(CW$request\fR was provided. .Sp The entries are returned with the most specific matches first. In scalar context returns the most specific match or \f(CW\*(C`undef\*(C'\fR in none match. .ie n .IP "$conf\->add_item( $item, %matchspec )" 4 .el .IP "\f(CW$conf\fR\->add_item( \f(CW$item\fR, \f(CW%matchspec\fR )" 4 .IX Item "$conf->add_item( $item, %matchspec )" .PD 0 .ie n .IP "$conf\->remove_items( %spec )" 4 .el .IP "\f(CW$conf\fR\->remove_items( \f(CW%spec\fR )" 4 .IX Item "$conf->remove_items( %spec )" .ie n .IP "$conf\->matching_items( $uri, $request, $response )" 4 .el .IP "\f(CW$conf\fR\->matching_items( \f(CW$uri\fR, \f(CW$request\fR, \f(CW$response\fR )" 4 .IX Item "$conf->matching_items( $uri, $request, $response )" .PD Wrappers that hides the entries themselves. .SS Matching .IX Subsection "Matching" The following keys on a configuration entry specify matching. For all of these you can provide an array of values instead of a single value. The entry matches if at least one of the values in the array matches. .PP Entries that require match against a response object attribute will never match unless a response object was provided. .ie n .IP "m_scheme => $scheme" 4 .el .IP "m_scheme => \f(CW$scheme\fR" 4 .IX Item "m_scheme => $scheme" Matches if the URI uses the specified scheme; e.g. "http". .ie n .IP "m_secure => $bool" 4 .el .IP "m_secure => \f(CW$bool\fR" 4 .IX Item "m_secure => $bool" If \f(CW$bool\fR is TRUE; matches if the URI uses a secure scheme. If \f(CW$bool\fR is FALSE; matches if the URI does not use a secure scheme. An example of a secure scheme is "https". .IP "m_host_port => ""$hostname:$port""" 4 .IX Item "m_host_port => ""$hostname:$port""" Matches if the URI\*(Aqs host_port method return the specified value. .ie n .IP "m_host => $hostname" 4 .el .IP "m_host => \f(CW$hostname\fR" 4 .IX Item "m_host => $hostname" Matches if the URI\*(Aqs host method returns the specified value. .ie n .IP "m_port => $port" 4 .el .IP "m_port => \f(CW$port\fR" 4 .IX Item "m_port => $port" Matches if the URI\*(Aqs port method returns the specified value. .IP "m_domain => "".$domain""" 4 .IX Item "m_domain => "".$domain""" Matches if the URI\*(Aqs host method return a value that within the given domain. The hostname "www.example.com" will for instance match the domain ".com". .ie n .IP "m_path => $path" 4 .el .IP "m_path => \f(CW$path\fR" 4 .IX Item "m_path => $path" Matches if the URI\*(Aqs path method returns the specified value. .ie n .IP "m_path_prefix => $path" 4 .el .IP "m_path_prefix => \f(CW$path\fR" 4 .IX Item "m_path_prefix => $path" Matches if the URI\*(Aqs path is the specified path or has the specified path as prefix. .ie n .IP "m_path_match => $Regexp" 4 .el .IP "m_path_match => \f(CW$Regexp\fR" 4 .IX Item "m_path_match => $Regexp" Matches if the regular expression matches the URI\*(Aqs path. Eg. qr/\e.html$/. .ie n .IP "m_method => $method" 4 .el .IP "m_method => \f(CW$method\fR" 4 .IX Item "m_method => $method" Matches if the request method matches the specified value. Eg. "GET" or "POST". .ie n .IP "m_code => $digit" 4 .el .IP "m_code => \f(CW$digit\fR" 4 .IX Item "m_code => $digit" .PD 0 .ie n .IP "m_code => $status_code" 4 .el .IP "m_code => \f(CW$status_code\fR" 4 .IX Item "m_code => $status_code" .PD Matches if the response status code matches. If a single digit is specified; matches for all response status codes beginning with that digit. .ie n .IP "m_proxy => $url" 4 .el .IP "m_proxy => \f(CW$url\fR" 4 .IX Item "m_proxy => $url" Matches if the request is to be sent to the given Proxy server. .IP "m_media_type => ""*/*""" 4 .IX Item "m_media_type => ""*/*""" .PD 0 .IP "m_media_type => ""text/*""" 4 .IX Item "m_media_type => ""text/*""" .IP "m_media_type => ""html""" 4 .IX Item "m_media_type => ""html""" .IP "m_media_type => ""xhtml""" 4 .IX Item "m_media_type => ""xhtml""" .IP "m_media_type => ""text/html""" 4 .IX Item "m_media_type => ""text/html""" .PD Matches if the response media type matches. .Sp With a value of "html" matches if \f(CW$response\fR\->content_is_html returns TRUE. With a value of "xhtml" matches if \f(CW$response\fR\->content_is_xhtml returns TRUE. .ie n .IP "m_uri_\|_\fR\fI$method\fR\fI\fR => undef" 4 .el .IP "m_uri_\|_\fR\f(CI$method\fR\fI\fR => undef" 4 .IX Item "m_uri__$method => undef" Matches if the URI object provides the method. .ie n .IP "m_uri_\|_\fR\fI$method\fR\fI\fR => $string" 4 .el .IP "m_uri_\|_\fR\f(CI$method\fR\fI\fR => \f(CW$string\fR" 4 .IX Item "m_uri__$method => $string" Matches if the URI\*(Aqs \f(CW$method\fR method returns the given value. .ie n .IP "m_header_\|_\fR\fI$field\fR\fI\fR => $string" 4 .el .IP "m_header_\|_\fR\f(CI$field\fR\fI\fR => \f(CW$string\fR" 4 .IX Item "m_header__$field => $string" Matches if either the request or the response have a header \f(CW$field\fR with the given value. .ie n .IP "m_response_attr_\|_\fR\fI$key\fR\fI\fR => undef" 4 .el .IP "m_response_attr_\|_\fR\f(CI$key\fR\fI\fR => undef" 4 .IX Item "m_response_attr__$key => undef" .PD 0 .ie n .IP "m_response_attr_\|_\fR\fI$key\fR\fI\fR => $string" 4 .el .IP "m_response_attr_\|_\fR\f(CI$key\fR\fI\fR => \f(CW$string\fR" 4 .IX Item "m_response_attr__$key => $string" .PD Matches if the response object has that key, or the entry has the given value. .SH "SEE ALSO" .IX Header "SEE ALSO" URI, HTTP::Request, HTTP::Response .SH AUTHOR .IX Header "AUTHOR" Gisle Aas .SH "COPYRIGHT AND LICENSE" .IX Header "COPYRIGHT AND LICENSE" This software is copyright (c) 1994 by Gisle Aas. .PP This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. lib/perl5/vendor_perl/man/man3/PaxHeader/HTTP::Headers.3000444 000000 000000 00000000025 15213024437 023172 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/man/man3/HTTP::Headers.3000444 000000 000000 00000046713 15213024437 021237 0ustar00rootwheel000000 000000 .\" -*- mode: troff; coding: utf-8 -*- .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45) .\" .\" Standard preamble: .\" ======================================================================== .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. .ie n \{\ . ds C` "" . ds C' "" 'br\} .el\{\ . ds C` . ds C' 'br\} .\" .\" Escape single quotes in literal strings from groff's Unicode transform. .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" .\" If the F register is >0, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .\" .\" Avoid warning from groff about undefined register 'F'. .de IX .. .nr rF 0 .if \n(.g .if rF .nr rF 1 .if (\n(rF:(\n(.g==0)) \{\ . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF .\" .\" Required to disable full justification in groff 1.23.0. .if n .ds AD l .\" ======================================================================== .\" .IX Title "HTTP::Headers 3" .TH HTTP::Headers 3 2026-06-05 "perl v5.42.2" "User Contributed Perl Documentation" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l .nh .SH NAME HTTP::Headers \- Class encapsulating HTTP Message headers .SH VERSION .IX Header "VERSION" version 7.02 .SH SYNOPSIS .IX Header "SYNOPSIS" .Vb 2 \& require HTTP::Headers; \& $h = HTTP::Headers\->new; \& \& $h\->header(\*(AqContent\-Type\*(Aq => \*(Aqtext/plain\*(Aq); # set \& $ct = $h\->header(\*(AqContent\-Type\*(Aq); # get \& $h\->remove_header(\*(AqContent\-Type\*(Aq); # delete .Ve .SH DESCRIPTION .IX Header "DESCRIPTION" The \f(CW\*(C`HTTP::Headers\*(C'\fR class encapsulates HTTP\-style message headers. The headers consist of attribute\-value pairs also called fields, which may be repeated, and which are printed in a particular order. The field names are cases insensitive. .PP Instances of this class are usually created as member variables of the \&\f(CW\*(C`HTTP::Request\*(C'\fR and \f(CW\*(C`HTTP::Response\*(C'\fR classes, internal to the library. .PP The following methods are available: .ie n .IP "$h = HTTP::Headers\->new" 4 .el .IP "\f(CW$h\fR = HTTP::Headers\->new" 4 .IX Item "$h = HTTP::Headers->new" Constructs a new \f(CW\*(C`HTTP::Headers\*(C'\fR object. You might pass some initial attribute\-value pairs as parameters to the constructor. \fIE.g.\fR: .Sp .Vb 4 \& $h = HTTP::Headers\->new( \& Date => \*(AqThu, 03 Feb 1994 00:00:00 GMT\*(Aq, \& Content_Type => \*(Aqtext/html; version=3.2\*(Aq, \& Content_Base => \*(Aqhttp://www.perl.org/\*(Aq); .Ve .Sp The constructor arguments are passed to the \f(CW\*(C`header\*(C'\fR method which is described below. .ie n .IP $h\->clone 4 .el .IP \f(CW$h\fR\->clone 4 .IX Item "$h->clone" Returns a copy of this \f(CW\*(C`HTTP::Headers\*(C'\fR object. .ie n .IP "$h\->header( $field )" 4 .el .IP "\f(CW$h\fR\->header( \f(CW$field\fR )" 4 .IX Item "$h->header( $field )" .PD 0 .ie n .IP "$h\->header( $field => $value )" 4 .el .IP "\f(CW$h\fR\->header( \f(CW$field\fR => \f(CW$value\fR )" 4 .IX Item "$h->header( $field => $value )" .ie n .IP "$h\->header( $f1 => $v1, $f2 => $v2, ... )" 4 .el .IP "\f(CW$h\fR\->header( \f(CW$f1\fR => \f(CW$v1\fR, \f(CW$f2\fR => \f(CW$v2\fR, ... )" 4 .IX Item "$h->header( $f1 => $v1, $f2 => $v2, ... )" .PD Get or set the value of one or more header fields. The header field name ($field) is not case sensitive. To make the life easier for perl users who wants to avoid quoting before the => operator, you can use \&\*(Aq_\*(Aq as a replacement for \*(Aq\-\*(Aq in header names. .Sp The \fBheader()\fR method accepts multiple ($field => \f(CW$value\fR) pairs, which means that you can update several fields with a single invocation. .Sp The \f(CW$value\fR argument may be a plain string or a reference to an array of strings for a multi\-valued field. If the \f(CW$value\fR is provided as \&\f(CW\*(C`undef\*(C'\fR then the field is removed. If the \f(CW$value\fR is not given, then that header field will remain unchanged. In addition to being a string, \&\f(CW$value\fR may be something that stringifies. .Sp The old value (or values) of the last of the header fields is returned. If no such field exists \f(CW\*(C`undef\*(C'\fR will be returned. .Sp A multi\-valued field will be returned as separate values in list context and will be concatenated with ", " as separator in scalar context. The HTTP spec (RFC 2616) promises that joining multiple values in this way will not change the semantic of a header field, but in practice there are cases like old\-style Netscape cookies (see HTTP::Cookies) where "," is used as part of the syntax of a single field value. .Sp Examples: .Sp .Vb 6 \& $header\->header(MIME_Version => \*(Aq1.0\*(Aq, \& User_Agent => \*(AqMy\-Web\-Client/0.01\*(Aq); \& $header\->header(Accept => "text/html, text/plain, image/*"); \& $header\->header(Accept => [qw(text/html text/plain image/*)]); \& @accepts = $header\->header(\*(AqAccept\*(Aq); # get multiple values \& $accepts = $header\->header(\*(AqAccept\*(Aq); # get values as a single string .Ve .ie n .IP "$h\->push_header( $field => $value )" 4 .el .IP "\f(CW$h\fR\->push_header( \f(CW$field\fR => \f(CW$value\fR )" 4 .IX Item "$h->push_header( $field => $value )" .PD 0 .ie n .IP "$h\->push_header( $f1 => $v1, $f2 => $v2, ... )" 4 .el .IP "\f(CW$h\fR\->push_header( \f(CW$f1\fR => \f(CW$v1\fR, \f(CW$f2\fR => \f(CW$v2\fR, ... )" 4 .IX Item "$h->push_header( $f1 => $v1, $f2 => $v2, ... )" .PD Add a new field value for the specified header field. Previous values for the same field are retained. .Sp As for the \fBheader()\fR method, the field name ($field) is not case sensitive and \*(Aq_\*(Aq can be used as a replacement for \*(Aq\-\*(Aq. .Sp The \f(CW$value\fR argument may be a scalar or a reference to a list of scalars. .Sp .Vb 2 \& $header\->push_header(Accept => \*(Aqimage/jpeg\*(Aq); \& $header\->push_header(Accept => [map "image/$_", qw(gif png tiff)]); .Ve .ie n .IP "$h\->init_header( $field => $value )" 4 .el .IP "\f(CW$h\fR\->init_header( \f(CW$field\fR => \f(CW$value\fR )" 4 .IX Item "$h->init_header( $field => $value )" Set the specified header to the given value, but only if no previous value for that field is set. .Sp The header field name ($field) is not case sensitive and \*(Aq_\*(Aq can be used as a replacement for \*(Aq\-\*(Aq. .Sp The \f(CW$value\fR argument may be a scalar or a reference to a list of scalars. .ie n .IP "$h\->remove_header( $field, ... )" 4 .el .IP "\f(CW$h\fR\->remove_header( \f(CW$field\fR, ... )" 4 .IX Item "$h->remove_header( $field, ... )" This function removes the header fields with the specified names. .Sp The header field names ($field) are not case sensitive and \*(Aq_\*(Aq can be used as a replacement for \*(Aq\-\*(Aq. .Sp The return value is the values of the fields removed. In scalar context the number of fields removed is returned. .Sp Note that if you pass in multiple field names then it is generally not possible to tell which of the returned values belonged to which field. .ie n .IP $h\->remove_content_headers 4 .el .IP \f(CW$h\fR\->remove_content_headers 4 .IX Item "$h->remove_content_headers" This will remove all the header fields used to describe the content of a message. All header field names prefixed with \f(CW\*(C`Content\-\*(C'\fR fall into this category, as well as \f(CW\*(C`Allow\*(C'\fR, \f(CW\*(C`Expires\*(C'\fR and \&\f(CW\*(C`Last\-Modified\*(C'\fR. RFC 2616 denotes these fields as \fIEntity Header Fields\fR. .Sp The return value is a new \f(CW\*(C`HTTP::Headers\*(C'\fR object that contains the removed headers only. .ie n .IP $h\->clear 4 .el .IP \f(CW$h\fR\->clear 4 .IX Item "$h->clear" This will remove all header fields. .ie n .IP $h\->header_field_names 4 .el .IP \f(CW$h\fR\->header_field_names 4 .IX Item "$h->header_field_names" Returns the list of distinct names for the fields present in the header. The field names have case as suggested by HTTP spec, and the names are returned in the recommended "Good Practice" order. .Sp In scalar context return the number of distinct field names. .ie n .IP "$h\->scan( \e&process_header_field )" 4 .el .IP "\f(CW$h\fR\->scan( \e&process_header_field )" 4 .IX Item "$h->scan( &process_header_field )" Apply a subroutine to each header field in turn. The callback routine is called with two parameters; the name of the field and a single value (a string). If a header field is multi\-valued, then the routine is called once for each value. The field name passed to the callback routine has case as suggested by HTTP spec, and the headers will be visited in the recommended "Good Practice" order. .Sp Any return values of the callback routine are ignored. The loop can be broken by raising an exception (\f(CW\*(C`die\*(C'\fR), but the caller of \fBscan()\fR would have to trap the exception itself. .ie n .IP $h\->\fBflatten()\fR 4 .el .IP \f(CW$h\fR\->\fBflatten()\fR 4 .IX Item "$h->flatten()" Returns the list of pairs of keys and values. .ie n .IP $h\->as_string 4 .el .IP \f(CW$h\fR\->as_string 4 .IX Item "$h->as_string" .PD 0 .ie n .IP "$h\->as_string( $eol )" 4 .el .IP "\f(CW$h\fR\->as_string( \f(CW$eol\fR )" 4 .IX Item "$h->as_string( $eol )" .PD Return the header fields as a formatted MIME header. Since it internally uses the \f(CW\*(C`scan\*(C'\fR method to build the string, the result will use case as suggested by HTTP spec, and it will follow recommended "Good Practice" of ordering the header fields. Long header values are not folded. .Sp The optional \f(CW$eol\fR parameter specifies the line ending sequence to use. The default is "\en". Embedded "\en" characters in header field values will be substituted with this line ending sequence. .SH "CONVENIENCE METHODS" .IX Header "CONVENIENCE METHODS" The most frequently used headers can also be accessed through the following convenience methods. Most of these methods can both be used to read and to set the value of a header. The header value is set if you pass an argument to the method. The old header value is always returned. If the given header did not exist then \f(CW\*(C`undef\*(C'\fR is returned. .PP Methods that deal with dates/times always convert their value to system time (seconds since Jan 1, 1970) and they also expect this kind of value when the header value is set. .ie n .IP $h\->date 4 .el .IP \f(CW$h\fR\->date 4 .IX Item "$h->date" This header represents the date and time at which the message was originated. \fIE.g.\fR: .Sp .Vb 1 \& $h\->date(time); # set current date .Ve .ie n .IP $h\->expires 4 .el .IP \f(CW$h\fR\->expires 4 .IX Item "$h->expires" This header gives the date and time after which the entity should be considered stale. .ie n .IP $h\->if_modified_since 4 .el .IP \f(CW$h\fR\->if_modified_since 4 .IX Item "$h->if_modified_since" .PD 0 .ie n .IP $h\->if_unmodified_since 4 .el .IP \f(CW$h\fR\->if_unmodified_since 4 .IX Item "$h->if_unmodified_since" .PD These header fields are used to make a request conditional. If the requested resource has (or has not) been modified since the time specified in this field, then the server will return a \f(CW\*(C`304 Not Modified\*(C'\fR response instead of the document itself. .ie n .IP $h\->last_modified 4 .el .IP \f(CW$h\fR\->last_modified 4 .IX Item "$h->last_modified" This header indicates the date and time at which the resource was last modified. \fIE.g.\fR: .Sp .Vb 6 \& # check if document is more than 1 hour old \& if (my $last_mod = $h\->last_modified) { \& if ($last_mod < time \- 60*60) { \& ... \& } \& } .Ve .ie n .IP $h\->content_type 4 .el .IP \f(CW$h\fR\->content_type 4 .IX Item "$h->content_type" The Content\-Type header field indicates the media type of the message content. \fIE.g.\fR: .Sp .Vb 1 \& $h\->content_type(\*(Aqtext/html\*(Aq); .Ve .Sp The value returned will be converted to lower case, and potential parameters will be chopped off and returned as a separate value if in an array context. If there is no such header field, then the empty string is returned. This makes it safe to do the following: .Sp .Vb 5 \& if ($h\->content_type eq \*(Aqtext/html\*(Aq) { \& # we enter this place even if the real header value happens to \& # be \*(AqTEXT/HTML; version=3.0\*(Aq \& ... \& } .Ve .ie n .IP $h\->content_type_charset 4 .el .IP \f(CW$h\fR\->content_type_charset 4 .IX Item "$h->content_type_charset" Returns the upper\-cased charset specified in the Content\-Type header. In list context return the lower\-cased bare content type followed by the upper\-cased charset. Both values will be \f(CW\*(C`undef\*(C'\fR if not specified in the header. .ie n .IP $h\->content_is_text 4 .el .IP \f(CW$h\fR\->content_is_text 4 .IX Item "$h->content_is_text" Returns TRUE if the Content\-Type header field indicate that the content is textual. .ie n .IP $h\->content_is_html 4 .el .IP \f(CW$h\fR\->content_is_html 4 .IX Item "$h->content_is_html" Returns TRUE if the Content\-Type header field indicate that the content is some kind of HTML (including XHTML). This method can\*(Aqt be used to set Content\-Type. .ie n .IP $h\->content_is_xhtml 4 .el .IP \f(CW$h\fR\->content_is_xhtml 4 .IX Item "$h->content_is_xhtml" Returns TRUE if the Content\-Type header field indicate that the content is XHTML. This method can\*(Aqt be used to set Content\-Type. .ie n .IP $h\->content_is_xml 4 .el .IP \f(CW$h\fR\->content_is_xml 4 .IX Item "$h->content_is_xml" Returns TRUE if the Content\-Type header field indicate that the content is XML. This method can\*(Aqt be used to set Content\-Type. .ie n .IP $h\->content_encoding 4 .el .IP \f(CW$h\fR\->content_encoding 4 .IX Item "$h->content_encoding" The Content\-Encoding header field is used as a modifier to the media type. When present, its value indicates what additional encoding mechanism has been applied to the resource. .ie n .IP $h\->content_length 4 .el .IP \f(CW$h\fR\->content_length 4 .IX Item "$h->content_length" A decimal number indicating the size in bytes of the message content. .ie n .IP $h\->content_language 4 .el .IP \f(CW$h\fR\->content_language 4 .IX Item "$h->content_language" The natural language(s) of the intended audience for the message content. The value is one or more language tags as defined by RFC 1766. Eg. "no" for some kind of Norwegian and "en\-US" for English the way it is written in the US. .ie n .IP $h\->title 4 .el .IP \f(CW$h\fR\->title 4 .IX Item "$h->title" The title of the document. In libwww\-perl this header will be initialized automatically from the ... element of HTML documents. \fIThis header is no longer part of the HTTP standard.\fR .ie n .IP $h\->user_agent 4 .el .IP \f(CW$h\fR\->user_agent 4 .IX Item "$h->user_agent" This header field is used in request messages and contains information about the user agent originating the request. \fIE.g.\fR: .Sp .Vb 1 \& $h\->user_agent(\*(AqMozilla/5.0 (compatible; MSIE 7.0; Windows NT 6.0)\*(Aq); .Ve .ie n .IP $h\->server 4 .el .IP \f(CW$h\fR\->server 4 .IX Item "$h->server" The server header field contains information about the software being used by the originating server program handling the request. .ie n .IP $h\->from 4 .el .IP \f(CW$h\fR\->from 4 .IX Item "$h->from" This header should contain an Internet e\-mail address for the human user who controls the requesting user agent. The address should be machine\-usable, as defined by RFC822. E.g.: .Sp .Vb 1 \& $h\->from(\*(AqKing Kong \*(Aq); .Ve .Sp \&\fIThis header is no longer part of the HTTP standard.\fR .ie n .IP $h\->referer 4 .el .IP \f(CW$h\fR\->referer 4 .IX Item "$h->referer" Used to specify the address (URI) of the document from which the requested resource address was obtained. .Sp The "Free On\-line Dictionary of Computing" as this to say about the word \fIreferer\fR: .Sp .Vb 6 \& A misspelling of "referrer" which \& somehow made it into the {HTTP} standard. A given {web \& page}\*(Aqs referer (sic) is the {URL} of whatever web page \& contains the link that the user followed to the current \& page. Most browsers pass this information as part of a \& request. \& \& (1998\-10\-19) .Ve .Sp By popular demand \f(CW\*(C`referrer\*(C'\fR exists as an alias for this method so you can avoid this misspelling in your programs and still send the right thing on the wire. .Sp When setting the referrer, this method removes the fragment from the given URI if it is present, as mandated by RFC2616. Note that the removal does \fInot\fR happen automatically if using the \fBheader()\fR, \&\fBpush_header()\fR or \fBinit_header()\fR methods to set the referrer. .ie n .IP $h\->www_authenticate 4 .el .IP \f(CW$h\fR\->www_authenticate 4 .IX Item "$h->www_authenticate" This header must be included as part of a \f(CW\*(C`401 Unauthorized\*(C'\fR response. The field value consist of a challenge that indicates the authentication scheme and parameters applicable to the requested URI. .ie n .IP $h\->proxy_authenticate 4 .el .IP \f(CW$h\fR\->proxy_authenticate 4 .IX Item "$h->proxy_authenticate" This header must be included in a \f(CW\*(C`407 Proxy Authentication Required\*(C'\fR response. .ie n .IP $h\->authorization 4 .el .IP \f(CW$h\fR\->authorization 4 .IX Item "$h->authorization" .PD 0 .ie n .IP $h\->proxy_authorization 4 .el .IP \f(CW$h\fR\->proxy_authorization 4 .IX Item "$h->proxy_authorization" .PD A user agent that wishes to authenticate itself with a server or a proxy, may do so by including these headers. .ie n .IP $h\->authorization_basic 4 .el .IP \f(CW$h\fR\->authorization_basic 4 .IX Item "$h->authorization_basic" This method is used to get or set an authorization header that use the "Basic Authentication Scheme". In array context it will return two values; the user name and the password. In scalar context it will return \fI"uname:password"\fR as a single string value. .Sp When used to set the header value, it expects two arguments. \fIE.g.\fR: .Sp .Vb 1 \& $h\->authorization_basic($uname, $password); .Ve .Sp The method will croak if the \f(CW$uname\fR contains a colon \*(Aq:\*(Aq. .ie n .IP $h\->proxy_authorization_basic 4 .el .IP \f(CW$h\fR\->proxy_authorization_basic 4 .IX Item "$h->proxy_authorization_basic" Same as \fBauthorization_basic()\fR but will set the "Proxy\-Authorization" header instead. .SH "NON\-CANONICALIZED FIELD NAMES" .IX Header "NON-CANONICALIZED FIELD NAMES" The header field name spelling is normally canonicalized including the \&\*(Aq_\*(Aq to \*(Aq\-\*(Aq translation. There are some application where this is not appropriate. Prefixing field names with \*(Aq:\*(Aq allow you to force a specific spelling. For example if you really want a header field name to show up as \f(CW\*(C`foo_bar\*(C'\fR instead of "Foo\-Bar", you might set it like this: .PP .Vb 1 \& $h\->header(":foo_bar" => 1); .Ve .PP These field names are returned with the \*(Aq:\*(Aq intact for \&\f(CW$h\fR\->header_field_names and the \f(CW$h\fR\->scan callback, but the colons do not show in \f(CW$h\fR\->as_string. .SH AUTHOR .IX Header "AUTHOR" Gisle Aas .SH "COPYRIGHT AND LICENSE" .IX Header "COPYRIGHT AND LICENSE" This software is copyright (c) 1994 by Gisle Aas. .PP This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. lib/perl5/vendor_perl/man/man3/PaxHeader/HTTP::Headers::Auth.3000444 000000 000000 00000000025 15213024437 024200 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/man/man3/HTTP::Headers::Auth.3000444 000000 000000 00000004003 15213024437 022227 0ustar00rootwheel000000 000000 .\" -*- mode: troff; coding: utf-8 -*- .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45) .\" .\" Standard preamble: .\" ======================================================================== .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. .ie n \{\ . ds C` "" . ds C' "" 'br\} .el\{\ . ds C` . ds C' 'br\} .\" .\" Escape single quotes in literal strings from groff's Unicode transform. .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" .\" If the F register is >0, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .\" .\" Avoid warning from groff about undefined register 'F'. .de IX .. .nr rF 0 .if \n(.g .if rF .nr rF 1 .if (\n(rF:(\n(.g==0)) \{\ . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF .\" .\" Required to disable full justification in groff 1.23.0. .if n .ds AD l .\" ======================================================================== .\" .IX Title "HTTP::Headers::Auth 3" .TH HTTP::Headers::Auth 3 2026-06-05 "perl v5.42.2" "User Contributed Perl Documentation" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l .nh .SH NAME HTTP::Headers::Auth .SH VERSION .IX Header "VERSION" version 7.02 .SH AUTHOR .IX Header "AUTHOR" Gisle Aas .SH "COPYRIGHT AND LICENSE" .IX Header "COPYRIGHT AND LICENSE" This software is copyright (c) 1994 by Gisle Aas. .PP This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. lib/perl5/vendor_perl/man/man3/PaxHeader/HTTP::Headers::ETag.3000444 000000 000000 00000000025 15213024437 024117 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/man/man3/HTTP::Headers::ETag.3000444 000000 000000 00000004003 15213024437 022146 0ustar00rootwheel000000 000000 .\" -*- mode: troff; coding: utf-8 -*- .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45) .\" .\" Standard preamble: .\" ======================================================================== .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. .ie n \{\ . ds C` "" . ds C' "" 'br\} .el\{\ . ds C` . ds C' 'br\} .\" .\" Escape single quotes in literal strings from groff's Unicode transform. .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" .\" If the F register is >0, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .\" .\" Avoid warning from groff about undefined register 'F'. .de IX .. .nr rF 0 .if \n(.g .if rF .nr rF 1 .if (\n(rF:(\n(.g==0)) \{\ . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF .\" .\" Required to disable full justification in groff 1.23.0. .if n .ds AD l .\" ======================================================================== .\" .IX Title "HTTP::Headers::ETag 3" .TH HTTP::Headers::ETag 3 2026-06-05 "perl v5.42.2" "User Contributed Perl Documentation" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l .nh .SH NAME HTTP::Headers::ETag .SH VERSION .IX Header "VERSION" version 7.02 .SH AUTHOR .IX Header "AUTHOR" Gisle Aas .SH "COPYRIGHT AND LICENSE" .IX Header "COPYRIGHT AND LICENSE" This software is copyright (c) 1994 by Gisle Aas. .PP This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. lib/perl5/vendor_perl/man/man3/PaxHeader/HTTP::Headers::Util.3000444 000000 000000 00000000025 15213024437 024214 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/man/man3/HTTP::Headers::Util.3000444 000000 000000 00000012666 15213024437 022261 0ustar00rootwheel000000 000000 .\" -*- mode: troff; coding: utf-8 -*- .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45) .\" .\" Standard preamble: .\" ======================================================================== .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. .ie n \{\ . ds C` "" . ds C' "" 'br\} .el\{\ . ds C` . ds C' 'br\} .\" .\" Escape single quotes in literal strings from groff's Unicode transform. .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" .\" If the F register is >0, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .\" .\" Avoid warning from groff about undefined register 'F'. .de IX .. .nr rF 0 .if \n(.g .if rF .nr rF 1 .if (\n(rF:(\n(.g==0)) \{\ . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF .\" .\" Required to disable full justification in groff 1.23.0. .if n .ds AD l .\" ======================================================================== .\" .IX Title "HTTP::Headers::Util 3" .TH HTTP::Headers::Util 3 2026-06-05 "perl v5.42.2" "User Contributed Perl Documentation" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l .nh .SH NAME HTTP::Headers::Util \- Header value parsing utility functions .SH VERSION .IX Header "VERSION" version 7.02 .SH SYNOPSIS .IX Header "SYNOPSIS" .Vb 2 \& use HTTP::Headers::Util qw(split_header_words); \& @values = split_header_words($h\->header("Content\-Type")); .Ve .SH DESCRIPTION .IX Header "DESCRIPTION" This module provides a few functions that helps parsing and construction of valid HTTP header values. None of the functions are exported by default. .PP The following functions are available: .ie n .IP "split_header_words( @header_values )" 4 .el .IP "split_header_words( \f(CW@header_values\fR )" 4 .IX Item "split_header_words( @header_values )" This function will parse the header values given as argument into a list of anonymous arrays containing key/value pairs. The function knows how to deal with ",", ";" and "=" as well as quoted values after "=". A list of space separated tokens are parsed as if they were separated by ";". .Sp If the \f(CW@header_values\fR passed as argument contains multiple values, then they are treated as if they were a single value separated by comma ",". .Sp This means that this function is useful for parsing header fields that follow this syntax (BNF as from the HTTP/1.1 specification, but we relax the requirement for tokens). .Sp .Vb 2 \& headers = #header \& header = (token | parameter) *( [";"] (token | parameter)) \& \& token = 1* \& separators = "(" | ")" | "<" | ">" | "@" \& | "," | ";" | ":" | "\e" | <"> \& | "/" | "[" | "]" | "?" | "=" \& | "{" | "}" | SP | HT \& \& quoted\-string = ( <"> *(qdtext | quoted\-pair ) <"> ) \& qdtext = > \& quoted\-pair = "\e" CHAR \& \& parameter = attribute "=" value \& attribute = token \& value = token | quoted\-string .Ve .Sp Each \fIheader\fR is represented by an anonymous array of key/value pairs. The keys will be all be forced to lower case. The value for a simple token (not part of a parameter) is \f(CW\*(C`undef\*(C'\fR. Syntactically incorrect headers will not necessarily be parsed as you would want. .Sp This is easier to describe with some examples: .Sp .Vb 3 \& split_header_words(\*(Aqfoo="bar"; port="80,81"; DISCARD, BAR=baz\*(Aq); \& split_header_words(\*(Aqtext/html; charset="iso\-8859\-1"\*(Aq); \& split_header_words(\*(AqBasic realm="\e\e"foo\e\e\e\ebar\e\e""\*(Aq); .Ve .Sp will return .Sp .Vb 3 \& [foo=>\*(Aqbar\*(Aq, port=>\*(Aq80,81\*(Aq, discard=> undef], [bar=>\*(Aqbaz\*(Aq ] \& [\*(Aqtext/html\*(Aq => undef, charset => \*(Aqiso\-8859\-1\*(Aq] \& [basic => undef, realm => "\e"foo\e\ebar\e""] .Ve .Sp If you don\*(Aqt want the function to convert tokens and attribute keys to lower case you can call it as \f(CW\*(C`_split_header_words\*(C'\fR instead (with a leading underscore). .ie n .IP "join_header_words( @arrays )" 4 .el .IP "join_header_words( \f(CW@arrays\fR )" 4 .IX Item "join_header_words( @arrays )" This will do the opposite of the conversion done by \fBsplit_header_words()\fR. It takes a list of anonymous arrays as arguments (or a list of key/value pairs) and produces a single header value. Attribute values are quoted if needed. .Sp Example: .Sp .Vb 2 \& join_header_words(["text/plain" => undef, charset => "iso\-8859/1"]); \& join_header_words("text/plain" => undef, charset => "iso\-8859/1"); .Ve .Sp will both return the string: .Sp .Vb 1 \& text/plain; charset="iso\-8859/1" .Ve .SH AUTHOR .IX Header "AUTHOR" Gisle Aas .SH "COPYRIGHT AND LICENSE" .IX Header "COPYRIGHT AND LICENSE" This software is copyright (c) 1994 by Gisle Aas. .PP This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. lib/perl5/vendor_perl/man/man3/PaxHeader/HTTP::Message.3000444 000000 000000 00000000025 15213024437 023203 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/man/man3/HTTP::Message.3000444 000000 000000 00000042356 15213024437 021247 0ustar00rootwheel000000 000000 .\" -*- mode: troff; coding: utf-8 -*- .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45) .\" .\" Standard preamble: .\" ======================================================================== .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. .ie n \{\ . ds C` "" . ds C' "" 'br\} .el\{\ . ds C` . ds C' 'br\} .\" .\" Escape single quotes in literal strings from groff's Unicode transform. .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" .\" If the F register is >0, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .\" .\" Avoid warning from groff about undefined register 'F'. .de IX .. .nr rF 0 .if \n(.g .if rF .nr rF 1 .if (\n(rF:(\n(.g==0)) \{\ . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF .\" .\" Required to disable full justification in groff 1.23.0. .if n .ds AD l .\" ======================================================================== .\" .IX Title "HTTP::Message 3" .TH HTTP::Message 3 2026-06-05 "perl v5.42.2" "User Contributed Perl Documentation" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l .nh .SH NAME HTTP::Message \- HTTP style message (base class) .SH VERSION .IX Header "VERSION" version 7.02 .SH SYNOPSIS .IX Header "SYNOPSIS" .Vb 1 \& use parent \*(AqHTTP::Message\*(Aq; .Ve .SH DESCRIPTION .IX Header "DESCRIPTION" An \f(CW\*(C`HTTP::Message\*(C'\fR object contains some headers and a content body. The following methods are available: .ie n .IP "$mess = HTTP::Message\->new" 4 .el .IP "\f(CW$mess\fR = HTTP::Message\->new" 4 .IX Item "$mess = HTTP::Message->new" .PD 0 .ie n .IP "$mess = HTTP::Message\->new( $headers )" 4 .el .IP "\f(CW$mess\fR = HTTP::Message\->new( \f(CW$headers\fR )" 4 .IX Item "$mess = HTTP::Message->new( $headers )" .ie n .IP "$mess = HTTP::Message\->new( $headers, $content )" 4 .el .IP "\f(CW$mess\fR = HTTP::Message\->new( \f(CW$headers\fR, \f(CW$content\fR )" 4 .IX Item "$mess = HTTP::Message->new( $headers, $content )" .PD This constructs a new message object. Normally you would want construct \f(CW\*(C`HTTP::Request\*(C'\fR or \f(CW\*(C`HTTP::Response\*(C'\fR objects instead. .Sp The optional \f(CW$header\fR argument should be a reference to an \&\f(CW\*(C`HTTP::Headers\*(C'\fR object or a plain array reference of key/value pairs. If an \f(CW\*(C`HTTP::Headers\*(C'\fR object is provided then a copy of it will be embedded into the constructed message, i.e. it will not be owned and can be modified afterwards without affecting the message. .Sp The optional \f(CW$content\fR argument should be a string of bytes. .ie n .IP "$mess = HTTP::Message\->parse( $str )" 4 .el .IP "\f(CW$mess\fR = HTTP::Message\->parse( \f(CW$str\fR )" 4 .IX Item "$mess = HTTP::Message->parse( $str )" This constructs a new message object by parsing the given string. .ie n .IP $mess\->headers 4 .el .IP \f(CW$mess\fR\->headers 4 .IX Item "$mess->headers" Returns the embedded \f(CW\*(C`HTTP::Headers\*(C'\fR object. .ie n .IP $mess\->headers_as_string 4 .el .IP \f(CW$mess\fR\->headers_as_string 4 .IX Item "$mess->headers_as_string" .PD 0 .ie n .IP "$mess\->headers_as_string( $eol )" 4 .el .IP "\f(CW$mess\fR\->headers_as_string( \f(CW$eol\fR )" 4 .IX Item "$mess->headers_as_string( $eol )" .PD Call the \fBas_string()\fR method for the headers in the message. This will be the same as .Sp .Vb 1 \& $mess\->headers\->as_string .Ve .Sp but it will make your program a whole character shorter :\-) .ie n .IP $mess\->content 4 .el .IP \f(CW$mess\fR\->content 4 .IX Item "$mess->content" .PD 0 .ie n .IP "$mess\->content( $bytes )" 4 .el .IP "\f(CW$mess\fR\->content( \f(CW$bytes\fR )" 4 .IX Item "$mess->content( $bytes )" .PD The \fBcontent()\fR method sets the raw content if an argument is given. If no argument is given the content is not touched. In either case the original raw content is returned. .Sp If the \f(CW\*(C`undef\*(C'\fR argument is given, the content is reset to its default value, which is an empty string. .Sp Note that the content should be a string of bytes. Strings in perl can contain characters outside the range of a byte. The \f(CW\*(C`Encode\*(C'\fR module can be used to turn such strings into a string of bytes. .ie n .IP "$mess\->add_content( $bytes )" 4 .el .IP "\f(CW$mess\fR\->add_content( \f(CW$bytes\fR )" 4 .IX Item "$mess->add_content( $bytes )" The \fBadd_content()\fR methods appends more data bytes to the end of the current content buffer. .ie n .IP "$mess\->add_content_utf8( $string )" 4 .el .IP "\f(CW$mess\fR\->add_content_utf8( \f(CW$string\fR )" 4 .IX Item "$mess->add_content_utf8( $string )" The \fBadd_content_utf8()\fR method appends the UTF\-8 bytes representing the string to the end of the current content buffer. .ie n .IP $mess\->content_ref 4 .el .IP \f(CW$mess\fR\->content_ref 4 .IX Item "$mess->content_ref" .PD 0 .ie n .IP "$mess\->content_ref( \e$bytes )" 4 .el .IP "\f(CW$mess\fR\->content_ref( \e$bytes )" 4 .IX Item "$mess->content_ref( $bytes )" .PD The \fBcontent_ref()\fR method will return a reference to content buffer string. It can be more efficient to access the content this way if the content is huge, and it can even be used for direct manipulation of the content, for instance: .Sp .Vb 1 \& ${$res\->content_ref} =~ s/\ebfoo\eb/bar/g; .Ve .Sp This example would modify the content buffer in\-place. .Sp If an argument is passed it will setup the content to reference some external source. The \fBcontent()\fR and \fBadd_content()\fR methods will automatically dereference scalar references passed this way. For other references \fBcontent()\fR will return the reference itself and \&\fBadd_content()\fR will refuse to do anything. .ie n .IP $mess\->content_charset 4 .el .IP \f(CW$mess\fR\->content_charset 4 .IX Item "$mess->content_charset" This returns the charset used by the content in the message. The charset is either found as the charset attribute of the \&\f(CW\*(C`Content\-Type\*(C'\fR header or by guessing. .Sp See for details about how charset is determined. .ie n .IP "$mess\->decoded_content( %options )" 4 .el .IP "\f(CW$mess\fR\->decoded_content( \f(CW%options\fR )" 4 .IX Item "$mess->decoded_content( %options )" Returns the content with any \f(CW\*(C`Content\-Encoding\*(C'\fR undone and, for textual content (\f(CW\*(C`Content\-Type\*(C'\fR values starting with \f(CW\*(C`text/\*(C'\fR, exactly matching \&\f(CW\*(C`application/xml\*(C'\fR, or ending with \f(CW\*(C`+xml\*(C'\fR), the raw content\*(Aqs character set decoded into Perl\*(Aqs Unicode string format. Note that this does not currently attempt to decode declared character sets for any other content types like \&\f(CW\*(C`application/json\*(C'\fR or \f(CW\*(C`application/javascript\*(C'\fR. If the \f(CW\*(C`Content\-Encoding\*(C'\fR or \f(CW\*(C`charset\*(C'\fR of the message is unknown, this method will fail by returning \&\f(CW\*(C`undef\*(C'\fR. .Sp The following options can be specified. .RS 4 .ie n .IP """charset""" 4 .el .IP \f(CWcharset\fR 4 .IX Item "charset" This overrides the charset parameter for text content. The value \&\f(CW\*(C`none\*(C'\fR can used to suppress decoding of the charset. .ie n .IP """default_charset""" 4 .el .IP \f(CWdefault_charset\fR 4 .IX Item "default_charset" This overrides the default charset guessed by \fBcontent_charset()\fR or if that fails "ISO\-8859\-1". .ie n .IP """alt_charset""" 4 .el .IP \f(CWalt_charset\fR 4 .IX Item "alt_charset" If decoding fails because the charset specified in the Content\-Type header isn\*(Aqt recognized by Perl\*(Aqs Encode module, then try decoding using this charset instead of failing. The \f(CW\*(C`alt_charset\*(C'\fR might be specified as \f(CW\*(C`none\*(C'\fR to simply return the string without any decoding of charset as alternative. .ie n .IP """charset_strict""" 4 .el .IP \f(CWcharset_strict\fR 4 .IX Item "charset_strict" Abort decoding if malformed characters is found in the content. By default you get the substitution character ("\ex{FFFD}") in place of malformed characters. .ie n .IP """raise_error""" 4 .el .IP \f(CWraise_error\fR 4 .IX Item "raise_error" If TRUE then raise an exception if not able to decode content. Reason might be that the specified \f(CW\*(C`Content\-Encoding\*(C'\fR or \f(CW\*(C`charset\*(C'\fR is not supported. If this option is FALSE, then \fBdecoded_content()\fR will return \&\f(CW\*(C`undef\*(C'\fR on errors, but will still set $@. .ie n .IP """ref""" 4 .el .IP \f(CWref\fR 4 .IX Item "ref" If TRUE then a reference to decoded content is returned. This might be more efficient in cases where the decoded content is identical to the raw content as no data copying is required in this case. .RE .RS 4 .RE .ie n .IP $mess\->decodable 4 .el .IP \f(CW$mess\fR\->decodable 4 .IX Item "$mess->decodable" .PD 0 .IP \fBHTTP::Message::decodable()\fR 4 .IX Item "HTTP::Message::decodable()" .PD This returns the encoding identifiers that \fBdecoded_content()\fR can process. In scalar context returns a comma separated string of identifiers. .Sp This value is suitable for initializing the \f(CW\*(C`Accept\-Encoding\*(C'\fR request header field. .ie n .IP $mess\->decode 4 .el .IP \f(CW$mess\fR\->decode 4 .IX Item "$mess->decode" This method tries to replace the content of the message with the decoded version and removes the \f(CW\*(C`Content\-Encoding\*(C'\fR header. Returns TRUE if successful and FALSE if not. .Sp If the message does not have a \f(CW\*(C`Content\-Encoding\*(C'\fR header this method does nothing and returns TRUE. .Sp Note that the content of the message is still bytes after this method has been called and you still need to call \fBdecoded_content()\fR if you want to process its content as a string. .ie n .IP "$mess\->encode( $encoding, ... )" 4 .el .IP "\f(CW$mess\fR\->encode( \f(CW$encoding\fR, ... )" 4 .IX Item "$mess->encode( $encoding, ... )" Apply the given encodings to the content of the message. Returns TRUE if successful. The "identity" (non\-)encoding is always supported; other currently supported encodings, subject to availability of required additional modules, are "gzip", "deflate", "x\-bzip2", "base64" and "br". .Sp A successful call to this function will set the \f(CW\*(C`Content\-Encoding\*(C'\fR header. .Sp Note that \f(CW\*(C`multipart/*\*(C'\fR or \f(CW\*(C`message/*\*(C'\fR messages can\*(Aqt be encoded and this method will croak if you try. .ie n .IP $mess\->parts 4 .el .IP \f(CW$mess\fR\->parts 4 .IX Item "$mess->parts" .PD 0 .ie n .IP "$mess\->parts( @parts )" 4 .el .IP "\f(CW$mess\fR\->parts( \f(CW@parts\fR )" 4 .IX Item "$mess->parts( @parts )" .ie n .IP "$mess\->parts( \e@parts )" 4 .el .IP "\f(CW$mess\fR\->parts( \e@parts )" 4 .IX Item "$mess->parts( @parts )" .PD Messages can be composite, i.e. contain other messages. The composite messages have a content type of \f(CW\*(C`multipart/*\*(C'\fR or \f(CW\*(C`message/*\*(C'\fR. This method give access to the contained messages. .Sp The argumentless form will return a list of \f(CW\*(C`HTTP::Message\*(C'\fR objects. If the content type of \f(CW$msg\fR is not \f(CW\*(C`multipart/*\*(C'\fR or \f(CW\*(C`message/*\*(C'\fR then this will return the empty list. In scalar context only the first object is returned. The returned message parts should be regarded as read\-only (future versions of this library might make it possible to modify the parent by modifying the parts). .Sp If the content type of \f(CW$msg\fR is \f(CW\*(C`message/*\*(C'\fR then there will only be one part returned. .Sp If the content type is \f(CW\*(C`message/http\*(C'\fR, then the return value will be either an \f(CW\*(C`HTTP::Request\*(C'\fR or an \f(CW\*(C`HTTP::Response\*(C'\fR object. .Sp If a \f(CW@parts\fR argument is given, then the content of the message will be modified. The array reference form is provided so that an empty list can be provided. The \f(CW@parts\fR array should contain \f(CW\*(C`HTTP::Message\*(C'\fR objects. The \f(CW@parts\fR objects are owned by \f(CW$mess\fR after this call and should not be modified or made part of other messages. .Sp When updating the message with this method and the old content type of \&\f(CW$mess\fR is not \f(CW\*(C`multipart/*\*(C'\fR or \f(CW\*(C`message/*\*(C'\fR, then the content type is set to \f(CW\*(C`multipart/mixed\*(C'\fR and all other content headers are cleared. .Sp This method will croak if the content type is \f(CW\*(C`message/*\*(C'\fR and more than one part is provided. .ie n .IP "$mess\->add_part( $part )" 4 .el .IP "\f(CW$mess\fR\->add_part( \f(CW$part\fR )" 4 .IX Item "$mess->add_part( $part )" This will add a part to a message. The \f(CW$part\fR argument should be another \f(CW\*(C`HTTP::Message\*(C'\fR object. If the previous content type of \&\f(CW$mess\fR is not \f(CW\*(C`multipart/*\*(C'\fR then the old content (together with all content headers) will be made part #1 and the content type made \&\f(CW\*(C`multipart/mixed\*(C'\fR before the new part is added. The \f(CW$part\fR object is owned by \f(CW$mess\fR after this call and should not be modified or made part of other messages. .Sp There is no return value. .ie n .IP $mess\->clear 4 .el .IP \f(CW$mess\fR\->clear 4 .IX Item "$mess->clear" Will clear the headers and set the content to the empty string. There is no return value .ie n .IP $mess\->protocol 4 .el .IP \f(CW$mess\fR\->protocol 4 .IX Item "$mess->protocol" .PD 0 .ie n .IP "$mess\->protocol( $proto )" 4 .el .IP "\f(CW$mess\fR\->protocol( \f(CW$proto\fR )" 4 .IX Item "$mess->protocol( $proto )" .PD Sets the HTTP protocol used for the message. The \fBprotocol()\fR is a string like \f(CW\*(C`HTTP/1.0\*(C'\fR or \f(CW\*(C`HTTP/1.1\*(C'\fR. .ie n .IP $mess\->clone 4 .el .IP \f(CW$mess\fR\->clone 4 .IX Item "$mess->clone" Returns a copy of the message object. .ie n .IP $mess\->as_string 4 .el .IP \f(CW$mess\fR\->as_string 4 .IX Item "$mess->as_string" .PD 0 .ie n .IP "$mess\->as_string( $eol )" 4 .el .IP "\f(CW$mess\fR\->as_string( \f(CW$eol\fR )" 4 .IX Item "$mess->as_string( $eol )" .PD Returns the message formatted as a single string. .Sp The optional \f(CW$eol\fR parameter specifies the line ending sequence to use. The default is "\en". If no \f(CW$eol\fR is given then as_string will ensure that the returned string is newline terminated (even when the message content is not). No extra newline is appended if an explicit \f(CW$eol\fR is passed. .ie n .IP "$mess\->dump( %opt )" 4 .el .IP "\f(CW$mess\fR\->dump( \f(CW%opt\fR )" 4 .IX Item "$mess->dump( %opt )" Returns the message formatted as a string. In void context print the string. .Sp This differs from \f(CW\*(C`$mess\->as_string\*(C'\fR in that it escapes the bytes of the content so that it\*(Aqs safe to print them and it limits how much content to print. The escapes syntax used is the same as for Perl\*(Aqs double quoted strings. If there is no content the string "(no content)" is shown in its place. .Sp Options to influence the output can be passed as key/value pairs. The following options are recognized: .RS 4 .ie n .IP "maxlength => $num" 4 .el .IP "maxlength => \f(CW$num\fR" 4 .IX Item "maxlength => $num" How much of the content to show. The default is 512. Set this to 0 for unlimited. .Sp If the content is longer then the string is chopped at the limit and the string "...\en(### more bytes not shown)" appended. .ie n .IP "no_content => $str" 4 .el .IP "no_content => \f(CW$str\fR" 4 .IX Item "no_content => $str" Replaces the "(no content)" marker. .ie n .IP "prefix => $str" 4 .el .IP "prefix => \f(CW$str\fR" 4 .IX Item "prefix => $str" A string that will be prefixed to each line of the dump. .RE .RS 4 .RE .PP All methods unknown to \f(CW\*(C`HTTP::Message\*(C'\fR itself are delegated to the \&\f(CW\*(C`HTTP::Headers\*(C'\fR object that is part of every message. This allows convenient access to these methods. Refer to HTTP::Headers for details of these methods: .PP .Vb 7 \& $mess\->header( $field => $val ) \& $mess\->push_header( $field => $val ) \& $mess\->init_header( $field => $val ) \& $mess\->remove_header( $field ) \& $mess\->remove_content_headers \& $mess\->header_field_names \& $mess\->scan( \e&doit ) \& \& $mess\->date \& $mess\->expires \& $mess\->if_modified_since \& $mess\->if_unmodified_since \& $mess\->last_modified \& $mess\->content_type \& $mess\->content_encoding \& $mess\->content_length \& $mess\->content_language \& $mess\->title \& $mess\->user_agent \& $mess\->server \& $mess\->from \& $mess\->referer \& $mess\->www_authenticate \& $mess\->authorization \& $mess\->proxy_authorization \& $mess\->authorization_basic \& $mess\->proxy_authorization_basic .Ve .SH AUTHOR .IX Header "AUTHOR" Gisle Aas .SH "COPYRIGHT AND LICENSE" .IX Header "COPYRIGHT AND LICENSE" This software is copyright (c) 1994 by Gisle Aas. .PP This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. lib/perl5/vendor_perl/man/man3/PaxHeader/HTTP::Request.3000444 000000 000000 00000000025 15213024437 023247 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/man/man3/HTTP::Request.3000444 000000 000000 00000023252 15213024437 021305 0ustar00rootwheel000000 000000 .\" -*- mode: troff; coding: utf-8 -*- .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45) .\" .\" Standard preamble: .\" ======================================================================== .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. .ie n \{\ . ds C` "" . ds C' "" 'br\} .el\{\ . ds C` . ds C' 'br\} .\" .\" Escape single quotes in literal strings from groff's Unicode transform. .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" .\" If the F register is >0, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .\" .\" Avoid warning from groff about undefined register 'F'. .de IX .. .nr rF 0 .if \n(.g .if rF .nr rF 1 .if (\n(rF:(\n(.g==0)) \{\ . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF .\" .\" Required to disable full justification in groff 1.23.0. .if n .ds AD l .\" ======================================================================== .\" .IX Title "HTTP::Request 3" .TH HTTP::Request 3 2026-06-05 "perl v5.42.2" "User Contributed Perl Documentation" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l .nh .SH NAME HTTP::Request \- HTTP style request message .SH VERSION .IX Header "VERSION" version 7.02 .SH SYNOPSIS .IX Header "SYNOPSIS" .Vb 2 \& require HTTP::Request; \& $request = HTTP::Request\->new(GET => \*(Aqhttp://www.example.com/\*(Aq); .Ve .PP and usually used like this: .PP .Vb 2 \& $ua = LWP::UserAgent\->new; \& $response = $ua\->request($request); .Ve .SH DESCRIPTION .IX Header "DESCRIPTION" \&\f(CW\*(C`HTTP::Request\*(C'\fR is a class encapsulating HTTP style requests, consisting of a request line, some headers, and a content body. Note that the LWP library uses HTTP style requests even for non\-HTTP protocols. Instances of this class are usually passed to the \&\fBrequest()\fR method of an \f(CW\*(C`LWP::UserAgent\*(C'\fR object. .PP \&\f(CW\*(C`HTTP::Request\*(C'\fR is a subclass of \f(CW\*(C`HTTP::Message\*(C'\fR and therefore inherits its methods. The following additional methods are available: .ie n .IP "$r = HTTP::Request\->new( $method, $uri )" 4 .el .IP "\f(CW$r\fR = HTTP::Request\->new( \f(CW$method\fR, \f(CW$uri\fR )" 4 .IX Item "$r = HTTP::Request->new( $method, $uri )" .PD 0 .ie n .IP "$r = HTTP::Request\->new( $method, $uri, $header )" 4 .el .IP "\f(CW$r\fR = HTTP::Request\->new( \f(CW$method\fR, \f(CW$uri\fR, \f(CW$header\fR )" 4 .IX Item "$r = HTTP::Request->new( $method, $uri, $header )" .ie n .IP "$r = HTTP::Request\->new( $method, $uri, $header, $content )" 4 .el .IP "\f(CW$r\fR = HTTP::Request\->new( \f(CW$method\fR, \f(CW$uri\fR, \f(CW$header\fR, \f(CW$content\fR )" 4 .IX Item "$r = HTTP::Request->new( $method, $uri, $header, $content )" .PD Constructs a new \f(CW\*(C`HTTP::Request\*(C'\fR object describing a request on the object \f(CW$uri\fR using method \f(CW$method\fR. The \f(CW$method\fR argument must be a string. The \f(CW$uri\fR argument can be either a string, or a reference to a \&\f(CW\*(C`URI\*(C'\fR object. The optional \f(CW$header\fR argument should be a reference to an \f(CW\*(C`HTTP::Headers\*(C'\fR object or a plain array reference of key/value pairs. The optional \f(CW$content\fR argument should be a string of bytes. .ie n .IP "$r = HTTP::Request\->parse( $str )" 4 .el .IP "\f(CW$r\fR = HTTP::Request\->parse( \f(CW$str\fR )" 4 .IX Item "$r = HTTP::Request->parse( $str )" This constructs a new request object by parsing the given string. .ie n .IP $r\->method 4 .el .IP \f(CW$r\fR\->method 4 .IX Item "$r->method" .PD 0 .ie n .IP "$r\->method( $val )" 4 .el .IP "\f(CW$r\fR\->method( \f(CW$val\fR )" 4 .IX Item "$r->method( $val )" .PD This is used to get/set the method attribute. The method should be a short string like "GET", "HEAD", "PUT", "PATCH" or "POST". .ie n .IP $r\->uri 4 .el .IP \f(CW$r\fR\->uri 4 .IX Item "$r->uri" .PD 0 .ie n .IP "$r\->uri( $val )" 4 .el .IP "\f(CW$r\fR\->uri( \f(CW$val\fR )" 4 .IX Item "$r->uri( $val )" .PD This is used to get/set the uri attribute. The \f(CW$val\fR can be a reference to a URI object or a plain string. If a string is given, then it should be parsable as an absolute URI. .ie n .IP "$r\->header( $field )" 4 .el .IP "\f(CW$r\fR\->header( \f(CW$field\fR )" 4 .IX Item "$r->header( $field )" .PD 0 .ie n .IP "$r\->header( $field => $value )" 4 .el .IP "\f(CW$r\fR\->header( \f(CW$field\fR => \f(CW$value\fR )" 4 .IX Item "$r->header( $field => $value )" .PD This is used to get/set header values and it is inherited from \&\f(CW\*(C`HTTP::Headers\*(C'\fR via \f(CW\*(C`HTTP::Message\*(C'\fR. See HTTP::Headers for details and other similar methods that can be used to access the headers. .ie n .IP $r\->accept_decodable 4 .el .IP \f(CW$r\fR\->accept_decodable 4 .IX Item "$r->accept_decodable" This will set the \f(CW\*(C`Accept\-Encoding\*(C'\fR header to the list of encodings that \fBdecoded_content()\fR can decode. .ie n .IP $r\->content 4 .el .IP \f(CW$r\fR\->content 4 .IX Item "$r->content" .PD 0 .ie n .IP "$r\->content( $bytes )" 4 .el .IP "\f(CW$r\fR\->content( \f(CW$bytes\fR )" 4 .IX Item "$r->content( $bytes )" .PD This is used to get/set the content and it is inherited from the \&\f(CW\*(C`HTTP::Message\*(C'\fR base class. See HTTP::Message for details and other methods that can be used to access the content. .Sp Note that the content should be a string of bytes. Strings in perl can contain characters outside the range of a byte. The \f(CW\*(C`Encode\*(C'\fR module can be used to turn such strings into a string of bytes. .ie n .IP $r\->as_string 4 .el .IP \f(CW$r\fR\->as_string 4 .IX Item "$r->as_string" .PD 0 .ie n .IP "$r\->as_string( $eol )" 4 .el .IP "\f(CW$r\fR\->as_string( \f(CW$eol\fR )" 4 .IX Item "$r->as_string( $eol )" .PD Method returning a textual representation of the request. .SH EXAMPLES .IX Header "EXAMPLES" Creating requests to be sent with LWP::UserAgent or others can be easy. Here are a few examples. .SS "Simple POST" .IX Subsection "Simple POST" Here, we\*(Aqll create a simple POST request that could be used to send JSON data to an endpoint. .PP .Vb 1 \& #!/usr/bin/env perl \& \& use strict; \& use warnings; \& \& use HTTP::Request (); \& use JSON::MaybeXS qw(encode_json); \& \& my $url = \*(Aqhttps://www.example.com/api/user/123\*(Aq; \& my $header = [\*(AqContent\-Type\*(Aq => \*(Aqapplication/json; charset=UTF\-8\*(Aq]; \& my $data = {foo => \*(Aqbar\*(Aq, baz => \*(Aqquux\*(Aq}; \& my $encoded_data = encode_json($data); \& \& my $r = HTTP::Request\->new(\*(AqPOST\*(Aq, $url, $header, $encoded_data); \& # at this point, we could send it via LWP::UserAgent \& # my $ua = LWP::UserAgent\->new(); \& # my $res = $ua\->request($r); .Ve .SS "Batch POST Request" .IX Subsection "Batch POST Request" Some services, like Google, allow multiple requests to be sent in one batch. for example. Using the \&\f(CW\*(C`add_part\*(C'\fR method from HTTP::Message makes this simple. .PP .Vb 1 \& #!/usr/bin/env perl \& \& use strict; \& use warnings; \& \& use HTTP::Request (); \& use JSON::MaybeXS qw(encode_json); \& \& my $auth_token = \*(Aqauth_token\*(Aq; \& my $batch_url = \*(Aqhttps://www.googleapis.com/batch\*(Aq; \& my $url = \*(Aqhttps://www.googleapis.com/drive/v3/files/fileId/permissions?fields=id\*(Aq; \& my $url_no_email = \*(Aqhttps://www.googleapis.com/drive/v3/files/fileId/permissions?fields=id&sendNotificationEmail=false\*(Aq; \& \& # generate a JSON post request for one of the batch entries \& my $req1 = build_json_request($url, { \& emailAddress => \*(Aqexample@appsrocks.com\*(Aq, \& role => "writer", \& type => "user", \& }); \& \& # generate a JSON post request for one of the batch entries \& my $req2 = build_json_request($url_no_email, { \& domain => "appsrocks.com", \& role => "reader", \& type => "domain", \& }); \& \& # generate a multipart request to send all of the other requests \& my $r = HTTP::Request\->new(\*(AqPOST\*(Aq, $batch_url, [ \& \*(AqAccept\-Encoding\*(Aq => \*(Aqgzip\*(Aq, \& # if we don\*(Aqt provide a boundary here, HTTP::Message will generate \& # one for us. We could use UUID::uuid() here if we wanted. \& \*(AqContent\-Type\*(Aq => \*(Aqmultipart/mixed; boundary=END_OF_PART\*(Aq \& ]); \& \& # add the two POST requests to the main request \& $r\->add_part($req1, $req2); \& # at this point, we could send it via LWP::UserAgent \& # my $ua = LWP::UserAgent\->new(); \& # my $res = $ua\->request($r); \& exit(); \& \& sub build_json_request { \& my ($url, $href) = @_; \& my $header = [\*(AqAuthorization\*(Aq => "Bearer $auth_token", \*(AqContent\-Type\*(Aq => \*(Aqapplication/json; charset=UTF\-8\*(Aq]; \& return HTTP::Request\->new(\*(AqPOST\*(Aq, $url, $header, encode_json($href)); \& } .Ve .SH "SEE ALSO" .IX Header "SEE ALSO" HTTP::Headers, HTTP::Message, HTTP::Request::Common, HTTP::Response .SH AUTHOR .IX Header "AUTHOR" Gisle Aas .SH "COPYRIGHT AND LICENSE" .IX Header "COPYRIGHT AND LICENSE" This software is copyright (c) 1994 by Gisle Aas. .PP This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. lib/perl5/vendor_perl/man/man3/PaxHeader/HTTP::Request::Common.3000444 000000 000000 00000000025 15213024437 024604 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/man/man3/HTTP::Request::Common.3000444 000000 000000 00000033723 15213024437 022646 0ustar00rootwheel000000 000000 .\" -*- mode: troff; coding: utf-8 -*- .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45) .\" .\" Standard preamble: .\" ======================================================================== .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. .ie n \{\ . ds C` "" . ds C' "" 'br\} .el\{\ . ds C` . ds C' 'br\} .\" .\" Escape single quotes in literal strings from groff's Unicode transform. .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" .\" If the F register is >0, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .\" .\" Avoid warning from groff about undefined register 'F'. .de IX .. .nr rF 0 .if \n(.g .if rF .nr rF 1 .if (\n(rF:(\n(.g==0)) \{\ . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF .\" .\" Required to disable full justification in groff 1.23.0. .if n .ds AD l .\" ======================================================================== .\" .IX Title "HTTP::Request::Common 3" .TH HTTP::Request::Common 3 2026-06-05 "perl v5.42.2" "User Contributed Perl Documentation" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l .nh .SH NAME HTTP::Request::Common \- Construct common HTTP::Request objects .SH VERSION .IX Header "VERSION" version 7.02 .SH SYNOPSIS .IX Header "SYNOPSIS" .Vb 7 \& use HTTP::Request::Common; \& $ua = LWP::UserAgent\->new; \& $ua\->request(GET \*(Aqhttp://www.sn.no/\*(Aq); \& $ua\->request(POST \*(Aqhttp://somewhere/foo\*(Aq, foo => bar, bar => foo); \& $ua\->request(PATCH \*(Aqhttp://somewhere/foo\*(Aq, foo => bar, bar => foo); \& $ua\->request(PUT \*(Aqhttp://somewhere/foo\*(Aq, foo => bar, bar => foo); \& $ua\->request(OPTIONS \*(Aqhttp://somewhere/foo\*(Aq, foo => bar, bar => foo); .Ve .SH DESCRIPTION .IX Header "DESCRIPTION" This module provides functions that return newly created \f(CW\*(C`HTTP::Request\*(C'\fR objects. These functions are usually more convenient to use than the standard \f(CW\*(C`HTTP::Request\*(C'\fR constructor for the most common requests. .PP Note that LWP::UserAgent has several convenience methods, including \&\f(CW\*(C`get\*(C'\fR, \f(CW\*(C`head\*(C'\fR, \f(CW\*(C`delete\*(C'\fR, \f(CW\*(C`post\*(C'\fR and \f(CW\*(C`put\*(C'\fR. .PP The following functions are provided: .ie n .IP "GET $url" 4 .el .IP "GET \f(CW$url\fR" 4 .IX Item "GET $url" .PD 0 .ie n .IP "GET $url, Header => Value,..." 4 .el .IP "GET \f(CW$url\fR, Header => Value,..." 4 .IX Item "GET $url, Header => Value,..." .PD The \f(CW\*(C`GET\*(C'\fR function returns an HTTP::Request object initialized with the "GET" method and the specified URL. It is roughly equivalent to the following call .Sp .Vb 4 \& HTTP::Request\->new( \& GET => $url, \& HTTP::Headers\->new(Header => Value,...), \& ) .Ve .Sp but is less cluttered. What is different is that a header named \&\f(CW\*(C`Content\*(C'\fR will initialize the content part of the request instead of setting a header field. Note that GET requests should normally not have a content, so this hack makes more sense for the \f(CW\*(C`PUT\*(C'\fR, \f(CW\*(C`PATCH\*(C'\fR and \f(CW\*(C`POST\*(C'\fR functions described below. .Sp The \f(CWget(...)\fR method of LWP::UserAgent exists as a shortcut for \&\f(CW\*(C`$ua\->request(GET ...)\*(C'\fR. .ie n .IP "HEAD $url" 4 .el .IP "HEAD \f(CW$url\fR" 4 .IX Item "HEAD $url" .PD 0 .ie n .IP "HEAD $url, Header => Value,..." 4 .el .IP "HEAD \f(CW$url\fR, Header => Value,..." 4 .IX Item "HEAD $url, Header => Value,..." .PD Like \fBGET()\fR but the method in the request is "HEAD". .Sp The \f(CWhead(...)\fR method of LWP::UserAgent exists as a shortcut for \&\f(CW\*(C`$ua\->request(HEAD ...)\*(C'\fR. .ie n .IP "DELETE $url" 4 .el .IP "DELETE \f(CW$url\fR" 4 .IX Item "DELETE $url" .PD 0 .ie n .IP "DELETE $url, Header => Value,..." 4 .el .IP "DELETE \f(CW$url\fR, Header => Value,..." 4 .IX Item "DELETE $url, Header => Value,..." .PD Like \f(CW\*(C`GET\*(C'\fR but the method in the request is \f(CW\*(C`DELETE\*(C'\fR. This function is not exported by default. .ie n .IP "PATCH $url" 4 .el .IP "PATCH \f(CW$url\fR" 4 .IX Item "PATCH $url" .PD 0 .ie n .IP "PATCH $url, Header => Value,..." 4 .el .IP "PATCH \f(CW$url\fR, Header => Value,..." 4 .IX Item "PATCH $url, Header => Value,..." .ie n .IP "PATCH $url, $form_ref, Header => Value,..." 4 .el .IP "PATCH \f(CW$url\fR, \f(CW$form_ref\fR, Header => Value,..." 4 .IX Item "PATCH $url, $form_ref, Header => Value,..." .ie n .IP "PATCH $url, Header => Value,..., Content => $form_ref" 4 .el .IP "PATCH \f(CW$url\fR, Header => Value,..., Content => \f(CW$form_ref\fR" 4 .IX Item "PATCH $url, Header => Value,..., Content => $form_ref" .ie n .IP "PATCH $url, Header => Value,..., Content => $content" 4 .el .IP "PATCH \f(CW$url\fR, Header => Value,..., Content => \f(CW$content\fR" 4 .IX Item "PATCH $url, Header => Value,..., Content => $content" .PD The same as \f(CW\*(C`POST\*(C'\fR below, but the method in the request is \f(CW\*(C`PATCH\*(C'\fR. .ie n .IP "PUT $url" 4 .el .IP "PUT \f(CW$url\fR" 4 .IX Item "PUT $url" .PD 0 .ie n .IP "PUT $url, Header => Value,..." 4 .el .IP "PUT \f(CW$url\fR, Header => Value,..." 4 .IX Item "PUT $url, Header => Value,..." .ie n .IP "PUT $url, $form_ref, Header => Value,..." 4 .el .IP "PUT \f(CW$url\fR, \f(CW$form_ref\fR, Header => Value,..." 4 .IX Item "PUT $url, $form_ref, Header => Value,..." .ie n .IP "PUT $url, Header => Value,..., Content => $form_ref" 4 .el .IP "PUT \f(CW$url\fR, Header => Value,..., Content => \f(CW$form_ref\fR" 4 .IX Item "PUT $url, Header => Value,..., Content => $form_ref" .ie n .IP "PUT $url, Header => Value,..., Content => $content" 4 .el .IP "PUT \f(CW$url\fR, Header => Value,..., Content => \f(CW$content\fR" 4 .IX Item "PUT $url, Header => Value,..., Content => $content" .PD The same as \f(CW\*(C`POST\*(C'\fR below, but the method in the request is \f(CW\*(C`PUT\*(C'\fR .ie n .IP "OPTIONS $url" 4 .el .IP "OPTIONS \f(CW$url\fR" 4 .IX Item "OPTIONS $url" .PD 0 .ie n .IP "OPTIONS $url, Header => Value,..." 4 .el .IP "OPTIONS \f(CW$url\fR, Header => Value,..." 4 .IX Item "OPTIONS $url, Header => Value,..." .ie n .IP "OPTIONS $url, $form_ref, Header => Value,..." 4 .el .IP "OPTIONS \f(CW$url\fR, \f(CW$form_ref\fR, Header => Value,..." 4 .IX Item "OPTIONS $url, $form_ref, Header => Value,..." .ie n .IP "OPTIONS $url, Header => Value,..., Content => $form_ref" 4 .el .IP "OPTIONS \f(CW$url\fR, Header => Value,..., Content => \f(CW$form_ref\fR" 4 .IX Item "OPTIONS $url, Header => Value,..., Content => $form_ref" .ie n .IP "OPTIONS $url, Header => Value,..., Content => $content" 4 .el .IP "OPTIONS \f(CW$url\fR, Header => Value,..., Content => \f(CW$content\fR" 4 .IX Item "OPTIONS $url, Header => Value,..., Content => $content" .PD The same as \f(CW\*(C`POST\*(C'\fR below, but the method in the request is \f(CW\*(C`OPTIONS\*(C'\fR .Sp This was added in version 6.21, so you should require that in your code: .Sp .Vb 1 \& use HTTP::Request::Common 6.21; .Ve .ie n .IP "POST $url" 4 .el .IP "POST \f(CW$url\fR" 4 .IX Item "POST $url" .PD 0 .ie n .IP "POST $url, Header => Value,..." 4 .el .IP "POST \f(CW$url\fR, Header => Value,..." 4 .IX Item "POST $url, Header => Value,..." .ie n .IP "POST $url, $form_ref, Header => Value,..." 4 .el .IP "POST \f(CW$url\fR, \f(CW$form_ref\fR, Header => Value,..." 4 .IX Item "POST $url, $form_ref, Header => Value,..." .ie n .IP "POST $url, Header => Value,..., Content => $form_ref" 4 .el .IP "POST \f(CW$url\fR, Header => Value,..., Content => \f(CW$form_ref\fR" 4 .IX Item "POST $url, Header => Value,..., Content => $form_ref" .ie n .IP "POST $url, Header => Value,..., Content => $content" 4 .el .IP "POST \f(CW$url\fR, Header => Value,..., Content => \f(CW$content\fR" 4 .IX Item "POST $url, Header => Value,..., Content => $content" .PD \&\f(CW\*(C`POST\*(C'\fR, \f(CW\*(C`PATCH\*(C'\fR and \f(CW\*(C`PUT\*(C'\fR all work with the same parameters. .Sp .Vb 4 \& %data = ( title => \*(Aqsomething\*(Aq, body => something else\*(Aq ); \& $ua = LWP::UserAgent\->new(); \& $request = HTTP::Request::Common::POST( $url, [ %data ] ); \& $response = $ua\->request($request); .Ve .Sp They take a second optional array or hash reference parameter \f(CW$form_ref\fR. The content can also be specified directly using the \f(CW\*(C`Content\*(C'\fR pseudo\-header, and you may also provide the \f(CW$form_ref\fR this way. .Sp The \f(CW\*(C`Content\*(C'\fR pseudo\-header steals a bit of the header field namespace as there is no way to directly specify a header that is actually called "Content". If you really need this you must update the request returned in a separate statement. .Sp The \f(CW$form_ref\fR argument can be used to pass key/value pairs for the form content. By default we will initialize a request using the \&\f(CW\*(C`application/x\-www\-form\-urlencoded\*(C'\fR content type. This means that you can emulate an HTML
POSTing like this: .Sp .Vb 7 \& POST \*(Aqhttp://www.perl.org/survey.cgi\*(Aq, \& [ name => \*(AqGisle Aas\*(Aq, \& email => \*(Aqgisle@aas.no\*(Aq, \& gender => \*(AqM\*(Aq, \& born => \*(Aq1964\*(Aq, \& perc => \*(Aq3%\*(Aq, \& ]; .Ve .Sp This will create an HTTP::Request object that looks like this: .Sp .Vb 3 \& POST http://www.perl.org/survey.cgi \& Content\-Length: 66 \& Content\-Type: application/x\-www\-form\-urlencoded \& \& name=Gisle%20Aas&email=gisle%40aas.no&gender=M&born=1964&perc=3%25 .Ve .Sp Multivalued form fields can be specified by either repeating the field name or by passing the value as an array reference. .Sp The POST method also supports the \f(CW\*(C`multipart/form\-data\*(C'\fR content used for \fIForm\-based File Upload\fR as specified in RFC 1867. You trigger this content format by specifying a content type of \f(CW\*(Aqform\-data\*(Aq\fR as one of the request headers. If one of the values in the \f(CW$form_ref\fR is an array reference, then it is treated as a file part specification with the following interpretation: .Sp .Vb 2 \& [ $file, $filename, Header => Value... ] \& [ undef, $filename, Header => Value,..., Content => $content ] .Ve .Sp The first value in the array ($file) is the name of a file to open. This file will be read and its content placed in the request. The routine will croak if the file can\*(Aqt be opened. Use an \f(CW\*(C`undef\*(C'\fR as \&\f(CW$file\fR value if you want to specify the content directly with a \&\f(CW\*(C`Content\*(C'\fR header. The \f(CW$filename\fR is the filename to report in the request. If this value is undefined, then the basename of the \f(CW$file\fR will be used. You can specify an empty string as \f(CW$filename\fR if you want to suppress sending the filename when you provide a \f(CW$file\fR value. .Sp If a \f(CW$file\fR is provided by no \f(CW\*(C`Content\-Type\*(C'\fR header, then \f(CW\*(C`Content\-Type\*(C'\fR and \f(CW\*(C`Content\-Encoding\*(C'\fR will be filled in automatically with the values returned by \f(CWLWP::MediaTypes::guess_media_type()\fR .Sp Sending my \fI~/.profile\fR to the survey used as example above can be achieved by this: .Sp .Vb 8 \& POST \*(Aqhttp://www.perl.org/survey.cgi\*(Aq, \& Content_Type => \*(Aqform\-data\*(Aq, \& Content => [ name => \*(AqGisle Aas\*(Aq, \& email => \*(Aqgisle@aas.no\*(Aq, \& gender => \*(AqM\*(Aq, \& born => \*(Aq1964\*(Aq, \& init => ["$ENV{HOME}/.profile"], \& ] .Ve .Sp This will create an HTTP::Request object that almost looks this (the boundary and the content of your \fI~/.profile\fR is likely to be different): .Sp .Vb 3 \& POST http://www.perl.org/survey.cgi \& Content\-Length: 388 \& Content\-Type: multipart/form\-data; boundary="6G+f" \& \& \-\-6G+f \& Content\-Disposition: form\-data; name="name" \& \& Gisle Aas \& \-\-6G+f \& Content\-Disposition: form\-data; name="email" \& \& gisle@aas.no \& \-\-6G+f \& Content\-Disposition: form\-data; name="gender" \& \& M \& \-\-6G+f \& Content\-Disposition: form\-data; name="born" \& \& 1964 \& \-\-6G+f \& Content\-Disposition: form\-data; name="init"; filename=".profile" \& Content\-Type: text/plain \& \& PATH=/local/perl/bin:$PATH \& export PATH \& \& \-\-6G+f\-\- .Ve .Sp If you set the \f(CW$DYNAMIC_FILE_UPLOAD\fR variable (exportable) to some TRUE value, then you get back a request object with a subroutine closure as the content attribute. This subroutine will read the content of any files on demand and return it in suitable chunks. This allow you to upload arbitrary big files without using lots of memory. You can even upload infinite files like \fI/dev/audio\fR if you wish; however, if the file is not a plain file, there will be no \f(CW\*(C`Content\-Length\*(C'\fR header defined for the request. Not all servers (or server applications) like this. Also, if the file(s) change in size between the time the \f(CW\*(C`Content\-Length\*(C'\fR is calculated and the time that the last chunk is delivered, the subroutine will \f(CW\*(C`Croak\*(C'\fR. .Sp The \f(CWpost(...)\fR method of LWP::UserAgent exists as a shortcut for \&\f(CW\*(C`$ua\->request(POST ...)\*(C'\fR. .SH "SEE ALSO" .IX Header "SEE ALSO" HTTP::Request, LWP::UserAgent .PP Also, there are some examples in "EXAMPLES" in HTTP::Request that you might find useful. For example, batch requests are explained there. .SH AUTHOR .IX Header "AUTHOR" Gisle Aas .SH "COPYRIGHT AND LICENSE" .IX Header "COPYRIGHT AND LICENSE" This software is copyright (c) 1994 by Gisle Aas. .PP This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. lib/perl5/vendor_perl/man/man3/PaxHeader/HTTP::Response.3000444 000000 000000 00000000025 15213024437 023415 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/man/man3/HTTP::Response.3000444 000000 000000 00000035377 15213024437 021466 0ustar00rootwheel000000 000000 .\" -*- mode: troff; coding: utf-8 -*- .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45) .\" .\" Standard preamble: .\" ======================================================================== .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. .ie n \{\ . ds C` "" . ds C' "" 'br\} .el\{\ . ds C` . ds C' 'br\} .\" .\" Escape single quotes in literal strings from groff's Unicode transform. .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" .\" If the F register is >0, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .\" .\" Avoid warning from groff about undefined register 'F'. .de IX .. .nr rF 0 .if \n(.g .if rF .nr rF 1 .if (\n(rF:(\n(.g==0)) \{\ . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF .\" .\" Required to disable full justification in groff 1.23.0. .if n .ds AD l .\" ======================================================================== .\" .IX Title "HTTP::Response 3" .TH HTTP::Response 3 2026-06-05 "perl v5.42.2" "User Contributed Perl Documentation" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l .nh .SH NAME HTTP::Response \- HTTP style response message .SH VERSION .IX Header "VERSION" version 7.02 .SH SYNOPSIS .IX Header "SYNOPSIS" Response objects are returned by the \fBrequest()\fR method of the \f(CW\*(C`LWP::UserAgent\*(C'\fR: .PP .Vb 8 \& # ... \& $response = $ua\->request($request); \& if ($response\->is_success) { \& print $response\->decoded_content; \& } \& else { \& print STDERR $response\->status_line, "\en"; \& } .Ve .SH DESCRIPTION .IX Header "DESCRIPTION" The \f(CW\*(C`HTTP::Response\*(C'\fR class encapsulates HTTP style responses. A response consists of a response line, some headers, and a content body. Note that the LWP library uses HTTP style responses even for non\-HTTP protocol schemes. Instances of this class are usually created and returned by the \fBrequest()\fR method of an \f(CW\*(C`LWP::UserAgent\*(C'\fR object. .PP \&\f(CW\*(C`HTTP::Response\*(C'\fR is a subclass of \f(CW\*(C`HTTP::Message\*(C'\fR and therefore inherits its methods. The following additional methods are available: .ie n .IP "$r = HTTP::Response\->new( $code )" 4 .el .IP "\f(CW$r\fR = HTTP::Response\->new( \f(CW$code\fR )" 4 .IX Item "$r = HTTP::Response->new( $code )" .PD 0 .ie n .IP "$r = HTTP::Response\->new( $code, $msg )" 4 .el .IP "\f(CW$r\fR = HTTP::Response\->new( \f(CW$code\fR, \f(CW$msg\fR )" 4 .IX Item "$r = HTTP::Response->new( $code, $msg )" .ie n .IP "$r = HTTP::Response\->new( $code, $msg, $header )" 4 .el .IP "\f(CW$r\fR = HTTP::Response\->new( \f(CW$code\fR, \f(CW$msg\fR, \f(CW$header\fR )" 4 .IX Item "$r = HTTP::Response->new( $code, $msg, $header )" .ie n .IP "$r = HTTP::Response\->new( $code, $msg, $header, $content )" 4 .el .IP "\f(CW$r\fR = HTTP::Response\->new( \f(CW$code\fR, \f(CW$msg\fR, \f(CW$header\fR, \f(CW$content\fR )" 4 .IX Item "$r = HTTP::Response->new( $code, $msg, $header, $content )" .PD Constructs a new \f(CW\*(C`HTTP::Response\*(C'\fR object describing a response with response code \f(CW$code\fR and optional message \f(CW$msg\fR. The optional \f(CW$header\fR argument should be a reference to an \f(CW\*(C`HTTP::Headers\*(C'\fR object or a plain array reference of key/value pairs. The optional \f(CW$content\fR argument should be a string of bytes. The meanings of these arguments are described below. .ie n .IP "$r = HTTP::Response\->parse( $str )" 4 .el .IP "\f(CW$r\fR = HTTP::Response\->parse( \f(CW$str\fR )" 4 .IX Item "$r = HTTP::Response->parse( $str )" This constructs a new response object by parsing the given string. .ie n .IP $r\->code 4 .el .IP \f(CW$r\fR\->code 4 .IX Item "$r->code" .PD 0 .ie n .IP "$r\->code( $code )" 4 .el .IP "\f(CW$r\fR\->code( \f(CW$code\fR )" 4 .IX Item "$r->code( $code )" .PD This is used to get/set the code attribute. The code is a 3 digit number that encode the overall outcome of an HTTP response. The \&\f(CW\*(C`HTTP::Status\*(C'\fR module provide constants that provide mnemonic names for the code attribute. .ie n .IP $r\->message 4 .el .IP \f(CW$r\fR\->message 4 .IX Item "$r->message" .PD 0 .ie n .IP "$r\->message( $message )" 4 .el .IP "\f(CW$r\fR\->message( \f(CW$message\fR )" 4 .IX Item "$r->message( $message )" .PD This is used to get/set the message attribute. The message is a short human readable single line string that explains the response code. .ie n .IP "$r\->header( $field )" 4 .el .IP "\f(CW$r\fR\->header( \f(CW$field\fR )" 4 .IX Item "$r->header( $field )" .PD 0 .ie n .IP "$r\->header( $field => $value )" 4 .el .IP "\f(CW$r\fR\->header( \f(CW$field\fR => \f(CW$value\fR )" 4 .IX Item "$r->header( $field => $value )" .PD This is used to get/set header values and it is inherited from \&\f(CW\*(C`HTTP::Headers\*(C'\fR via \f(CW\*(C`HTTP::Message\*(C'\fR. See HTTP::Headers for details and other similar methods that can be used to access the headers. .ie n .IP $r\->content 4 .el .IP \f(CW$r\fR\->content 4 .IX Item "$r->content" .PD 0 .ie n .IP "$r\->content( $bytes )" 4 .el .IP "\f(CW$r\fR\->content( \f(CW$bytes\fR )" 4 .IX Item "$r->content( $bytes )" .PD This is used to get/set the raw content and it is inherited from the \&\f(CW\*(C`HTTP::Message\*(C'\fR base class. See HTTP::Message for details and other methods that can be used to access the content. .ie n .IP "$r\->decoded_content( %options )" 4 .el .IP "\f(CW$r\fR\->decoded_content( \f(CW%options\fR )" 4 .IX Item "$r->decoded_content( %options )" This will return the content after any \f(CW\*(C`Content\-Encoding\*(C'\fR and charsets have been decoded. See HTTP::Message for details. .ie n .IP $r\->request 4 .el .IP \f(CW$r\fR\->request 4 .IX Item "$r->request" .PD 0 .ie n .IP "$r\->request( $request )" 4 .el .IP "\f(CW$r\fR\->request( \f(CW$request\fR )" 4 .IX Item "$r->request( $request )" .PD This is used to get/set the request attribute. The request attribute is a reference to the request that caused this response. It does not have to be the same request passed to the \f(CW$ua\fR\->\fBrequest()\fR method, because there might have been redirects and authorization retries in between. .ie n .IP $r\->previous 4 .el .IP \f(CW$r\fR\->previous 4 .IX Item "$r->previous" .PD 0 .ie n .IP "$r\->previous( $response )" 4 .el .IP "\f(CW$r\fR\->previous( \f(CW$response\fR )" 4 .IX Item "$r->previous( $response )" .PD This is used to get/set the previous attribute. The previous attribute is used to link together chains of responses. You get chains of responses if the first response is redirect or unauthorized. The value is \f(CW\*(C`undef\*(C'\fR if this is the first response in a chain. .Sp Note that the method \f(CW$r\fR\->redirects is provided as a more convenient way to access the response chain. .ie n .IP $r\->status_line 4 .el .IP \f(CW$r\fR\->status_line 4 .IX Item "$r->status_line" Returns the string " ". If the message attribute is not set then the official name of (see HTTP::Status) is substituted. .ie n .IP $r\->base 4 .el .IP \f(CW$r\fR\->base 4 .IX Item "$r->base" Returns the base URI for this response. The return value will be a reference to a URI object. .Sp The base URI is obtained from one the following sources (in priority order): .RS 4 .IP 1. 4 Embedded in the document content, for instance in HTML documents. .IP 2. 4 A "Content\-Base:" header in the response. .Sp For backwards compatibility with older HTTP implementations we will also look for the "Base:" header. .IP 3. 4 The URI used to request this response. This might not be the original URI that was passed to \f(CW$ua\fR\->\fBrequest()\fR method, because we might have received some redirect responses first. .RE .RS 4 .Sp If none of these sources provide an absolute URI, undef is returned. .Sp \&\fBNote\fR: previous versions of HTTP::Response would also consider a "Content\-Location:" header, as RFC 2616 said it should be. But this was never widely implemented by browsers, and now RFC 7231 says it should no longer be considered. .Sp When the LWP protocol modules produce the HTTP::Response object, then any base URI embedded in the document (step 1) will already have initialized the "Content\-Base:" header. (See "parse_head" in LWP::UserAgent). This means that this method only performs the last 2 steps (the content is not always available either). .RE .ie n .IP $r\->filename 4 .el .IP \f(CW$r\fR\->filename 4 .IX Item "$r->filename" Returns a filename for this response. Note that doing sanity checks on the returned filename (eg. removing characters that cannot be used on the target filesystem where the filename would be used, and laundering it for security purposes) are the caller\*(Aqs responsibility; the only related thing done by this method is that it makes a simple attempt to return a plain filename with no preceding path segments. .Sp The filename is obtained from one the following sources (in priority order): .RS 4 .IP 1. 4 A "Content\-Disposition:" header in the response. Proper decoding of RFC 2047 encoded filenames requires the \f(CW\*(C`MIME::QuotedPrint\*(C'\fR (for "Q" encoding), \f(CW\*(C`MIME::Base64\*(C'\fR (for "B" encoding), and \f(CW\*(C`Encode\*(C'\fR modules. .IP 2. 4 A "Content\-Location:" header in the response. .IP 3. 4 The URI used to request this response. This might not be the original URI that was passed to \f(CW$ua\fR\->\fBrequest()\fR method, because we might have received some redirect responses first. .RE .RS 4 .Sp If a filename cannot be derived from any of these sources, undef is returned. .RE .ie n .IP $r\->as_string 4 .el .IP \f(CW$r\fR\->as_string 4 .IX Item "$r->as_string" .PD 0 .ie n .IP "$r\->as_string( $eol )" 4 .el .IP "\f(CW$r\fR\->as_string( \f(CW$eol\fR )" 4 .IX Item "$r->as_string( $eol )" .PD Returns a textual representation of the response. .ie n .IP $r\->is_info 4 .el .IP \f(CW$r\fR\->is_info 4 .IX Item "$r->is_info" .PD 0 .ie n .IP $r\->is_success 4 .el .IP \f(CW$r\fR\->is_success 4 .IX Item "$r->is_success" .ie n .IP $r\->is_redirect 4 .el .IP \f(CW$r\fR\->is_redirect 4 .IX Item "$r->is_redirect" .ie n .IP $r\->is_error 4 .el .IP \f(CW$r\fR\->is_error 4 .IX Item "$r->is_error" .ie n .IP $r\->is_client_error 4 .el .IP \f(CW$r\fR\->is_client_error 4 .IX Item "$r->is_client_error" .ie n .IP $r\->is_server_error 4 .el .IP \f(CW$r\fR\->is_server_error 4 .IX Item "$r->is_server_error" .PD These methods indicate if the response was informational, successful, a redirection, or an error. See HTTP::Status for the meaning of these. .ie n .IP $r\->error_as_HTML 4 .el .IP \f(CW$r\fR\->error_as_HTML 4 .IX Item "$r->error_as_HTML" Returns a string containing a complete HTML document indicating what error occurred. This method should only be called when \f(CW$r\fR\->is_error is TRUE. .ie n .IP $r\->redirects 4 .el .IP \f(CW$r\fR\->redirects 4 .IX Item "$r->redirects" Returns the list of redirect responses that lead up to this response by following the \f(CW$r\fR\->previous chain. The list order is oldest first. .Sp In scalar context return the number of redirect responses leading up to this one. .ie n .IP $r\->current_age 4 .el .IP \f(CW$r\fR\->current_age 4 .IX Item "$r->current_age" Calculates the "current age" of the response as specified by RFC 2616 section 13.2.3. The age of a response is the time since it was sent by the origin server. The returned value is a number representing the age in seconds. .ie n .IP "$r\->freshness_lifetime( %opt )" 4 .el .IP "\f(CW$r\fR\->freshness_lifetime( \f(CW%opt\fR )" 4 .IX Item "$r->freshness_lifetime( %opt )" Calculates the "freshness lifetime" of the response as specified by RFC 2616 section 13.2.4. The "freshness lifetime" is the length of time between the generation of a response and its expiration time. The returned value is the number of seconds until expiry. .Sp If the response does not contain an "Expires" or a "Cache\-Control" header, then this function will apply some simple heuristic based on the "Last\-Modified" header to determine a suitable lifetime. The following options might be passed to control the heuristics: .RS 4 .ie n .IP "heuristic_expiry => $bool" 4 .el .IP "heuristic_expiry => \f(CW$bool\fR" 4 .IX Item "heuristic_expiry => $bool" If passed as a FALSE value, don\*(Aqt apply heuristics and just return \&\f(CW\*(C`undef\*(C'\fR when "Expires" or "Cache\-Control" is lacking. .ie n .IP "h_lastmod_fraction => $num" 4 .el .IP "h_lastmod_fraction => \f(CW$num\fR" 4 .IX Item "h_lastmod_fraction => $num" This number represent the fraction of the difference since the "Last\-Modified" timestamp to make the expiry time. The default is \&\f(CW0.10\fR, the suggested typical setting of 10% in RFC 2616. .ie n .IP "h_min => $sec" 4 .el .IP "h_min => \f(CW$sec\fR" 4 .IX Item "h_min => $sec" This is the lower limit of the heuristic expiry age to use. The default is \f(CW60\fR (1 minute). .ie n .IP "h_max => $sec" 4 .el .IP "h_max => \f(CW$sec\fR" 4 .IX Item "h_max => $sec" This is the upper limit of the heuristic expiry age to use. The default is \f(CW86400\fR (24 hours). .ie n .IP "h_default => $sec" 4 .el .IP "h_default => \f(CW$sec\fR" 4 .IX Item "h_default => $sec" This is the expiry age to use when nothing else applies. The default is \f(CW3600\fR (1 hour) or "h_min" if greater. .RE .RS 4 .RE .ie n .IP "$r\->is_fresh( %opt )" 4 .el .IP "\f(CW$r\fR\->is_fresh( \f(CW%opt\fR )" 4 .IX Item "$r->is_fresh( %opt )" Returns TRUE if the response is fresh, based on the values of \&\fBfreshness_lifetime()\fR and \fBcurrent_age()\fR. If the response is no longer fresh, then it has to be re\-fetched or re\-validated by the origin server. .Sp Options might be passed to control expiry heuristics, see the description of \fBfreshness_lifetime()\fR. .ie n .IP "$r\->fresh_until( %opt )" 4 .el .IP "\f(CW$r\fR\->fresh_until( \f(CW%opt\fR )" 4 .IX Item "$r->fresh_until( %opt )" Returns the time (seconds since epoch) when this entity is no longer fresh. .Sp Options might be passed to control expiry heuristics, see the description of \fBfreshness_lifetime()\fR. .SH "SEE ALSO" .IX Header "SEE ALSO" HTTP::Headers, HTTP::Message, HTTP::Status, HTTP::Request .SH AUTHOR .IX Header "AUTHOR" Gisle Aas .SH "COPYRIGHT AND LICENSE" .IX Header "COPYRIGHT AND LICENSE" This software is copyright (c) 1994 by Gisle Aas. .PP This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. lib/perl5/vendor_perl/man/man3/PaxHeader/HTTP::Status.3000444 000000 000000 00000000025 15213024437 023102 xustar00rootwheel000000 000000 21 hdrcharset=BINARY lib/perl5/vendor_perl/man/man3/HTTP::Status.3000444 000000 000000 00000023333 15213024437 021140 0ustar00rootwheel000000 000000 .\" -*- mode: troff; coding: utf-8 -*- .\" Automatically generated by Pod::Man v6.0.2 (Pod::Simple 3.45) .\" .\" Standard preamble: .\" ======================================================================== .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. .ie n \{\ . ds C` "" . ds C' "" 'br\} .el\{\ . ds C` . ds C' 'br\} .\" .\" Escape single quotes in literal strings from groff's Unicode transform. .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" .\" If the F register is >0, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .\" .\" Avoid warning from groff about undefined register 'F'. .de IX .. .nr rF 0 .if \n(.g .if rF .nr rF 1 .if (\n(rF:(\n(.g==0)) \{\ . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF .\" .\" Required to disable full justification in groff 1.23.0. .if n .ds AD l .\" ======================================================================== .\" .IX Title "HTTP::Status 3" .TH HTTP::Status 3 2026-06-05 "perl v5.42.2" "User Contributed Perl Documentation" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l .nh .SH NAME HTTP::Status \- HTTP Status code processing .SH VERSION .IX Header "VERSION" version 7.02 .SH SYNOPSIS .IX Header "SYNOPSIS" .Vb 1 \& use HTTP::Status qw(:constants :is status_message); \& \& if ($rc != HTTP_OK) { \& print status_message($rc), "\en"; \& } \& \& if (is_success($rc)) { ... } \& if (is_error($rc)) { ... } \& if (is_redirect($rc)) { ... } .Ve .SH DESCRIPTION .IX Header "DESCRIPTION" \&\fIHTTP::Status\fR is a library of routines for defining and classifying HTTP status codes for libwww\-perl. Status codes are used to encode the overall outcome of an HTTP response message. Codes correspond to those defined in RFC 2616 and RFC 2518. .SH CONSTANTS .IX Header "CONSTANTS" The following constant functions can be used as mnemonic status code names. None of these are exported by default. Use the \f(CW\*(C`:constants\*(C'\fR tag to import them all. .PP .Vb 4 \& HTTP_CONTINUE (100) \& HTTP_SWITCHING_PROTOCOLS (101) \& HTTP_PROCESSING (102) \& HTTP_EARLY_HINTS (103) \& \& HTTP_OK (200) \& HTTP_CREATED (201) \& HTTP_ACCEPTED (202) \& HTTP_NON_AUTHORITATIVE_INFORMATION (203) \& HTTP_NO_CONTENT (204) \& HTTP_RESET_CONTENT (205) \& HTTP_PARTIAL_CONTENT (206) \& HTTP_MULTI_STATUS (207) \& HTTP_ALREADY_REPORTED (208) \& \& HTTP_IM_USED (226) \& \& HTTP_MULTIPLE_CHOICES (300) \& HTTP_MOVED_PERMANENTLY (301) \& HTTP_FOUND (302) \& HTTP_SEE_OTHER (303) \& HTTP_NOT_MODIFIED (304) \& HTTP_USE_PROXY (305) \& HTTP_TEMPORARY_REDIRECT (307) \& HTTP_PERMANENT_REDIRECT (308) \& \& HTTP_BAD_REQUEST (400) \& HTTP_UNAUTHORIZED (401) \& HTTP_PAYMENT_REQUIRED (402) \& HTTP_FORBIDDEN (403) \& HTTP_NOT_FOUND (404) \& HTTP_METHOD_NOT_ALLOWED (405) \& HTTP_NOT_ACCEPTABLE (406) \& HTTP_PROXY_AUTHENTICATION_REQUIRED (407) \& HTTP_REQUEST_TIMEOUT (408) \& HTTP_CONFLICT (409) \& HTTP_GONE (410) \& HTTP_LENGTH_REQUIRED (411) \& HTTP_PRECONDITION_FAILED (412) \& HTTP_CONTENT_TOO_LARGE (413) \& HTTP_URI_TOO_LONG (414) \& HTTP_UNSUPPORTED_MEDIA_TYPE (415) \& HTTP_RANGE_NOT_SATISFIABLE (416) \& HTTP_EXPECTATION_FAILED (417) \& HTTP_MISDIRECTED REQUEST (421) \& HTTP_UNPROCESSABLE_CONTENT (422) \& HTTP_LOCKED (423) \& HTTP_FAILED_DEPENDENCY (424) \& HTTP_TOO_EARLY (425) \& HTTP_UPGRADE_REQUIRED (426) \& HTTP_PRECONDITION_REQUIRED (428) \& HTTP_TOO_MANY_REQUESTS (429) \& HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE (431) \& HTTP_UNAVAILABLE_FOR_LEGAL_REASONS (451) \& \& HTTP_INTERNAL_SERVER_ERROR (500) \& HTTP_NOT_IMPLEMENTED (501) \& HTTP_BAD_GATEWAY (502) \& HTTP_SERVICE_UNAVAILABLE (503) \& HTTP_GATEWAY_TIMEOUT (504) \& HTTP_HTTP_VERSION_NOT_SUPPORTED (505) \& HTTP_VARIANT_ALSO_NEGOTIATES (506) \& HTTP_INSUFFICIENT_STORAGE (507) \& HTTP_LOOP_DETECTED (508) \& HTTP_NOT_EXTENDED (510) \& HTTP_NETWORK_AUTHENTICATION_REQUIRED (511) .Ve .SH FUNCTIONS .IX Header "FUNCTIONS" The following additional functions are provided. Most of them are exported by default. The \f(CW\*(C`:is\*(C'\fR import tag can be used to import all the classification functions. .ie n .IP "status_message( $code )" 4 .el .IP "status_message( \f(CW$code\fR )" 4 .IX Item "status_message( $code )" The \fBstatus_message()\fR function will translate status codes to human readable strings. The string is the same as found in the constant names above. For example, \f(CWstatus_message(303)\fR will return \f(CW"Not Found"\fR. .Sp If the \f(CW$code\fR is not registered in the list of IANA HTTP Status Codes then \f(CW\*(C`undef\*(C'\fR is returned. .ie n .IP "status_constant_name( $code )" 4 .el .IP "status_constant_name( \f(CW$code\fR )" 4 .IX Item "status_constant_name( $code )" The \fBstatus_constant_name()\fR function will translate a status code to a string which has the name of the constant for that status code. For example, \f(CWstatus_constant_name(404)\fR will return \f(CW"HTTP_NOT_FOUND"\fR. .Sp If the \f(CW$code\fR is not registered in the list of IANA HTTP Status Codes then \f(CW\*(C`undef\*(C'\fR is returned. .ie n .IP "is_info( $code )" 4 .el .IP "is_info( \f(CW$code\fR )" 4 .IX Item "is_info( $code )" Return TRUE if \f(CW$code\fR is an \fIInformational\fR status code (1xx). This class of status code indicates a provisional response which can\*(Aqt have any content. .ie n .IP "is_success( $code )" 4 .el .IP "is_success( \f(CW$code\fR )" 4 .IX Item "is_success( $code )" Return TRUE if \f(CW$code\fR is a \fISuccessful\fR status code (2xx). .ie n .IP "is_redirect( $code )" 4 .el .IP "is_redirect( \f(CW$code\fR )" 4 .IX Item "is_redirect( $code )" Return TRUE if \f(CW$code\fR is a \fIRedirection\fR status code (3xx). This class of status code indicates that further action needs to be taken by the user agent in order to fulfill the request. .ie n .IP "is_error( $code )" 4 .el .IP "is_error( \f(CW$code\fR )" 4 .IX Item "is_error( $code )" Return TRUE if \f(CW$code\fR is an \fIError\fR status code (4xx or 5xx). The function returns TRUE for both client and server error status codes. .ie n .IP "is_client_error( $code )" 4 .el .IP "is_client_error( \f(CW$code\fR )" 4 .IX Item "is_client_error( $code )" Return TRUE if \f(CW$code\fR is a \fIClient Error\fR status code (4xx). This class of status code is intended for cases in which the client seems to have erred. .Sp This function is \fBnot\fR exported by default. .ie n .IP "is_server_error( $code )" 4 .el .IP "is_server_error( \f(CW$code\fR )" 4 .IX Item "is_server_error( $code )" Return TRUE if \f(CW$code\fR is a \fIServer Error\fR status code (5xx). This class of status codes is intended for cases in which the server is aware that it has erred or is incapable of performing the request. .Sp This function is \fBnot\fR exported by default. .ie n .IP "is_cacheable_by_default( $code )" 4 .el .IP "is_cacheable_by_default( \f(CW$code\fR )" 4 .IX Item "is_cacheable_by_default( $code )" Return TRUE if \f(CW$code\fR indicates that a response is cacheable by default, and it can be reused by a cache with heuristic expiration. All other status codes are not cacheable by default. See RFC 7231 \- HTTP/1.1 Semantics and Content, Section 6.1. Overview of Status Codes . .Sp This function is \fBnot\fR exported by default. .IP status_codes 4 .IX Item "status_codes" Returns a hash mapping numerical HTTP status code (e.g. 200) to text status messages (e.g. "OK") .Sp This function is \fBnot\fR exported by default. .SH "SEE ALSO" .IX Header "SEE ALSO" IANA HTTP Status Codes .SH BUGS .IX Header "BUGS" For legacy reasons all the \f(CW\*(C`HTTP_\*(C'\fR constants are exported by default with the prefix \f(CW\*(C`RC_\*(C'\fR. It\*(Aqs recommended to use explicit imports and the \f(CW\*(C`:constants\*(C'\fR tag instead of relying on this. .SH AUTHOR .IX Header "AUTHOR" Gisle Aas .SH "COPYRIGHT AND LICENSE" .IX Header "COPYRIGHT AND LICENSE" This software is copyright (c) 1994 by Gisle Aas. .PP This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.