From f78b5d5b3f3583c2c39400e4ea56f6a724254511 Mon Sep 17 00:00:00 2001 From: John Hurliman Date: Fri, 2 Jun 2006 06:42:12 +0000 Subject: [PATCH] * Updated keywords.txt file to Second Life 1.10.1.0 * Removed test_app, replaced with examples directory * Added sldump to examples. Uses boost.program_options and dumps packets to the console in a readable format * Minor cleanups in the library git-svn-id: http://libopenmetaverse.googlecode.com/svn/trunk@13 52acb1d6-8a22-11de-b505-999d5b087335 --- Jamfile | 6 +- bin/keywords.txt | 59 +- examples/sldump/Jamfile | 12 + examples/sldump/sldump.cpp | 240 ++++++ include/Fields.h | 3 - include/Network.h | 3 - include/Packet.h | 6 +- include/PacketBuilder.h | 3 - include/ProtocolManager.h | 3 - include/SecondLife.h | 3 - include/SimConnection.h | 3 - include/curl/curl.h | 1450 ++++++++++++++++++++++++++++++++++++ include/curl/curlver.h | 56 ++ include/curl/easy.h | 81 ++ include/curl/mprintf.h | 55 ++ include/curl/multi.h | 341 +++++++++ include/curl/stdcheaders.h | 34 + include/curl/types.h | 1 + include/includes.h | 15 +- src/Network.cpp | 26 +- src/Packet.cpp | 53 +- src/ProtocolManager.cpp | 55 +- src/functions.cpp | 12 +- test_app/Jamfile | 6 - test_app/main.cpp | 132 ---- 25 files changed, 2403 insertions(+), 255 deletions(-) create mode 100755 examples/sldump/Jamfile create mode 100755 examples/sldump/sldump.cpp create mode 100755 include/curl/curl.h create mode 100755 include/curl/curlver.h create mode 100755 include/curl/easy.h create mode 100755 include/curl/mprintf.h create mode 100755 include/curl/multi.h create mode 100755 include/curl/stdcheaders.h create mode 100755 include/curl/types.h delete mode 100644 test_app/Jamfile delete mode 100644 test_app/main.cpp diff --git a/Jamfile b/Jamfile index 2b42754d..969926e5 100644 --- a/Jamfile +++ b/Jamfile @@ -1,5 +1,5 @@ project libsecondlife - : requirements include + : requirements include F:\\Boost\\include\\ : default-build debug ; @@ -23,8 +23,6 @@ if $(UNIX) lib secondlife : [ glob src/*.cpp ] - openssl - libcrypto libcurl boostthread $(SOCKET_LIBS) @@ -32,4 +30,4 @@ lib secondlife debug:DEBUG ; -build-project test_app ; +build-project examples/sldump ; diff --git a/bin/keywords.txt b/bin/keywords.txt index f0bd6ef2..1c00e129 100644 --- a/bin/keywords.txt +++ b/bin/keywords.txt @@ -35,6 +35,7 @@ MoneyTransactionsRequest GroupAccountTransactionsRequest MapNameRequest MailTaskSimRequest +LandScriptsRequest UpdateSimulator BillableFactor ObjectBonusFactor @@ -89,15 +90,17 @@ InventoryFile ObjectPermissions RevokePermissions UpdateFlags +ObjectExportSelected RezSelected AutoPilot UpdateMuteListEntry RemoveMuteListEntry -SimStatusInDatabase +SetSimStatusInDatabase SetSimPresenceInDatabase CameraProperty GroupRecallBallot BrushSize +StartExpungeProcess SimulatorSetMap RegionPresenceRequestByRegionID TransferEnergy @@ -112,10 +115,12 @@ AgentRequestSit AABBMin ClassifiedFlags ControlFlags +TeleportRequest SpaceLocationTeleportRequest LeaderBoardRequest ScriptTeleportRequest DateUTC +TaskIDs RequestResult ReputationAgentAssign CanAcceptAgents @@ -140,6 +145,7 @@ UpdateInventoryItem MoveInventoryItem CopyInventoryItem RemoveInventoryItem +CreateInventoryItem PathTwistBegin CRC AttachmentPoint @@ -162,6 +168,7 @@ MapBlockReply PropertiesData ViewerEffect FreezeUser +ScriptTime ObjectGrab ToAgentID ProxyBlock @@ -213,7 +220,6 @@ NewName AgentID OnlineStatusRequest DataAgentAccessRequest -AvatarNotesRequest EventNotificationRemoveRequest Arc NewFolderID @@ -230,6 +236,7 @@ DataPacket ObjectDehinge You ScriptControlChange +LoadURL SetCPURatio NameValueData AtomicPassObject @@ -246,7 +253,6 @@ FailedResends CameraCenter CameraLeftAxis ExBlock -ScriptBlock Channel NetTest DiscardLevel @@ -310,7 +316,7 @@ AggregatePermInventory SimulatorInfo MoneyTransactionsReply GroupAccountTransactionsReply -MultiTaskSimReply +MailTaskSimReply WearableData StatisticsData AccessOK @@ -327,6 +333,7 @@ LiveHelpGroupRequest ServerVersion PriceParcelClaimFactor BillableArea +ScriptCount ObjectID ObjectFlagUpdate ActiveOnly @@ -335,8 +342,11 @@ RedoLand TravelAccess ChangedGrid Details +LocationX SaleType ObjectExportReply +LocationY +LocationZ EconomyData HeadRotation DeleteOnCompletion @@ -409,7 +419,6 @@ ClosestSimulator Version OtherCount ChatData -GhostData IsGroupOwned EnergyEfficiency MaxPlace @@ -444,8 +453,10 @@ FetchInventoryReply MoneySummaryReply GroupAccountSummaryReply AttachedSound +ParamInUse GodKickUser PickName +TaskName SkillFlags ParcelGodReserveForNewbie SubType @@ -544,6 +555,7 @@ GodExpungeUser QueryReplies ObjectCategory Time +CreateLandmarkForEvent ParentID Ping Perp @@ -559,7 +571,6 @@ West ElectionData Undo Info -CheckCircuitsTime Area Behavior SimCrashed @@ -623,6 +634,7 @@ LeaderBoardData RequestBlock GrantData DetachAttachmentIntoInv +ParcelDisableObjects GodLevel StartGroupIM PayPriceReply @@ -644,7 +656,6 @@ ParamValue GroupVoteHistoryRequest Checksum MaxAgents -NumAttachments CreateNewOutfitAttachments RegionHandle TeleportProgress @@ -655,6 +666,7 @@ ParcelName InviteOfficers PriceObjectRent ConnectAgentToUserserver +ConnectToUserserver OfferCallingCard AgentAccess AcceptCallingCard @@ -668,6 +680,7 @@ TerseDateID ObjectOwner AssetID AlertMessage +AgentAlertMessage EstateOwnerMessage ParcelMediaCommandMessage Auction @@ -705,7 +718,7 @@ SalePrice Animation CurrentDividend OwnerID -NearestLandingRegionUpdate +NearestLandingRegionUpdated PassToAgent PreyAgent SimStats @@ -719,7 +732,7 @@ TransferData WantToMask AvatarData ParcelSelectObjects -TopObjects +ExtraParams LogLogin CreatorID Summary @@ -808,6 +821,7 @@ TemplateChecksumRequest AgentPresenceRequest ClassifiedInfoRequest ParcelInfoRequest +ParcelObjectOwnersRequest TeleportLandmarkRequest CommandID MovedIntoSimulator @@ -822,6 +836,7 @@ TextureID GroupOfficersAndMembersRequest OldFolderID UserInfoRequest +LandCollidersRequest Handle StartParcelRenameAck StateLoad @@ -931,7 +946,6 @@ TransferRequest ScriptSensorRequest MoneyTransferRequest EjectGroupMemberRequest -MapPopularRequest SkillsText Resent Center @@ -942,6 +956,7 @@ Viewer Method TouchName CandidateID +ParamData GodlikeMessage SystemMessage BodyRotation @@ -1017,6 +1032,7 @@ MapBlockRequest LureID CopyCenters RegisterNewAgent +TotalColliderCount ParamList InventorySerial EdgeDataPacket @@ -1064,12 +1080,15 @@ LogoutDemand HistoryData VoteData EstimatedDividend +ParamSize VoteCast EveryoneMask +CastsShadows SetSunPhase ObjectSpinUpdate MaturePublish UseExistingAsset +ParcelLocalID TeleportCancel UnixTime QueryFlags @@ -1082,6 +1101,7 @@ ViewerStats RegionHandshake Description ObjectDescription +ParamType UUIDNameReply UUIDGroupNameReply SaveAssetIntoInventory @@ -1098,12 +1118,12 @@ DirPlacesQuery Distance SortOrder Hunter +TotalScriptCount SunAngVelocity InventoryUpdate ImagePacket BinaryBucket StartGroupProposal -PhysicsTime EnergyLevel PriceForListing Scale @@ -1118,8 +1138,6 @@ ObjectRotation SitRotation SnapSelection TerrainRaiseLimit -SourceName -TerrainRaiseLimit Quorum TokenBlock AgentBlock @@ -1233,6 +1251,7 @@ ParcelObjectBonus TransactionBlock PowersMask Stamp +RelatedID TotalCredits State TextureIndex @@ -1285,6 +1304,7 @@ TeleportFinish PathRevolutions ClassifiedInfoReply ParcelInfoReply +LandCollidersReply AutosaveData SetStartLocation PassHours @@ -1319,6 +1339,7 @@ Rotation Selection TransactionData OperationData +ExpirationDate AgentName ParcelDeedToGroup DirPicksReply @@ -1329,6 +1350,7 @@ NextOwnerMask MuteData PassPrice SourceID +TotalScriptTime ShowMembersInGroupDir TeleportFlags AssetData @@ -1343,6 +1365,7 @@ UserListReply IsPhantom AgentList RezObject +TaskLocalID ClaimDate MergeParcel Priority @@ -1360,7 +1383,7 @@ OpenCircuit SecureSessionID CrossedRegion DirGroupsReply -AvatarsGroupReply +AvatarGroupsReply EmailMessageReply GroupVoteHistoryItemReply ViewerPosition @@ -1398,7 +1421,6 @@ ParcelSales CurrentInterval PriceRentLight MediaAutoScale -PriceRentLight NeighborBlock LayerData NVPairData @@ -1407,6 +1429,7 @@ LayersPaused VoteInitiator MailPingBounce TypeData +OwnerIDs SystemKickUser ErrorCode SLXML_ID @@ -1441,9 +1464,11 @@ SimWideTotalObjects TotalObjects GroupObjects ParcelReturnObjects +ObjectExtraParams Questions TransferAbort TransferInventory +LandScriptsReply Collada_ID RayTargetID ClaimPrice @@ -1467,6 +1492,7 @@ SpaceLocationTeleportReply IMViaEMail StartExpungeProcessAck RentPrice +GenericMessage ChildAgentAlive SpawnPointBlock AttachmentBlock @@ -1474,7 +1500,8 @@ RecallData OfficerData GroupOfficer ObjectMaterial +OwnerName AvatarNotesReply CacheID OwnerMask -TransferInventoryAck \ No newline at end of file +TransferInventoryAck diff --git a/examples/sldump/Jamfile b/examples/sldump/Jamfile new file mode 100755 index 00000000..090244f6 --- /dev/null +++ b/examples/sldump/Jamfile @@ -0,0 +1,12 @@ +project sldump + : default-build debug + : build-dir ../../bin + ; + +lib boostoptions : : boost_program_options ; + +exe sldump + : [ glob *.cpp ] + boostoptions + ../..//secondlife + ; diff --git a/examples/sldump/sldump.cpp b/examples/sldump/sldump.cpp new file mode 100755 index 00000000..b1015e4d --- /dev/null +++ b/examples/sldump/sldump.cpp @@ -0,0 +1,240 @@ +/* + * Copyright (c) 2006, Second Life Reverse Engineering Team + * All rights reserved. + * + * - Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * - Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * - Neither the name of the Second Life Reverse Engineering Team nor the names + * of its contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +#include + +#include "SecondLife.h" + +using namespace std; +namespace po = boost::program_options; + +SecondLife* client; + +void loginHandler(loginParameters login) +{ + if (login.reason.length()) { + cout << "test_app: Login failed. Reason: " << login.reason << ", Message: " << login.message << endl; + } else { + while (1) { + client->tick(); + } + } +} + +void receivedPacket(string command, PacketPtr packet) +{ + FieldList::iterator field; + BlockList::iterator block; + BlockList blocks = packet->getBlocks(); + + byte* u8; + unsigned short* u16; + unsigned int* u32; + unsigned long long* u64; + char* s8; + short* s16; + int* s32; + long long* s64; + float* f32; + double* f64; + + // Print the packet name + cout << "----" << packet->name() << "----" << endl; + + for (block = blocks.begin(); block != blocks.end(); ++block) { + // Print the block name + cout << "\t" << (*block)->name() << endl; + + for (field = (*block)->fields.begin(); field != (*block)->fields.end(); ++field) { + // Print the field name + cout << "\t\t" << (*field)->name() << ": "; + + switch ((*field)->type()) { + case types::U8: + u8 = (*field)->data; + // Prevent this from being misinterpreted as a character + u16 = (unsigned short*)u8; + cout << *u16 << endl; + break; + case types::U16: + u16 = (unsigned short*)(*field)->data; + cout << *u16 << endl; + break; + case types::U32: + u32 = (unsigned int*)(*field)->data; + cout << *u32 << endl; + break; + case types::U64: + u64 = (unsigned long long*)(*field)->data; + cout << *u64 << endl; + break; + case types::S8: + s8 = (char*)(*field)->data; + // Prevent this from being misinterpreted as a character + s16 = (short*)s8; + cout << *s16 << endl; + break; + case types::S16: + s16 = (short*)(*field)->data; + cout << *s16 << endl; + break; + case types::S32: + s32 = (int*)(*field)->data; + cout << *s32 << endl; + break; + case types::S64: + s64 = (long long*)(*field)->data; + cout << *s64 << endl; + break; + case types::F32: + f32 = (float*)(*field)->data; + cout << *f32 << endl; + break; + case types::F64: + f64 = (double*)(*field)->data; + cout << *f64 << endl; + break; + case types::LLUUID: + for (size_t i = 0; i < 16; ++i) { + printf("%02x", *((*field)->data + i)); + } + cout << endl; + break; + case types::Bool: + u8 = (*field)->data; + cout << ((*u8) ? "true" : "false") << endl; + break; + case types::LLVector3: + //FIXME + cout << endl; + break; + case types::LLVector3d: + //FIXME + cout << endl; + break; + case types::LLVector4: + //FIXME + cout << endl; + break; + case types::LLQuaternion: + //FIXME + cout << endl; + break; + case types::IPADDR: + //FIXME + cout << endl; + break; + case types::IPPORT: + u16 = (unsigned short*)(*field)->data; + cout << *u16 << endl; + break; + case types::Variable: + cout << (char*)(*field)->data << endl; + break; + default: + cout << "PARSING ERROR" << endl; + break; + } + } + } +} + +int main(int ac, char** av) +{ + string keywordFile; + string commFile; + string firstName; + string lastName; + string password; + + // Declare the supported options + po::options_description desc("Allowed options"); + desc.add_options() + ("help", "produce help message") + ("protocol-map", "dump the interpreted comm.dat to the console") + ("keywords,k", po::value(&keywordFile)->default_value("keywords.txt"), "keywords.txt file") + ("comm,c", po::value(&commFile)->default_value("comm.dat"), "comm.dat file") + ("first,f", po::value(&firstName), "account first name") + ("last,l", po::value(&lastName), "account last name") + ("password,pass,p", po::value(&password), "account password") + ; + + po::variables_map vm; + po::store(po::command_line_parser(ac, av).options(desc).run(), vm); + po::notify(vm); + + if (!vm.count("protocol-map")) { + if (vm.count("help") || !vm.count("first") || !vm.count("last") || !vm.count("password")) { + cout << desc << "\n"; + return 1; + } + } + + client = new SecondLife(); + + if (client->loadKeywords("keywords.txt") == 0) { + cout << "test_app: Loaded keyword file" << endl; + } else { + cout << "test_app: Failed to load the keyword file" << endl; + + delete client; + return 2; + } + + if (client->decryptCommFile("comm.dat", "output.txt") == 0) { + cout << "test_app: Decrypted comm file" << endl; + } else { + cout << "test_app: Failed to decrypt the comm file" << endl; + + delete client; + return -2; + } + + if (client->buildProtocolMap("output.txt") == 0) { + cout << "test_app: Built protocol map" << endl; + } else { + cout << "test_app: Failed to build the protocol map" << endl; + + delete client; + return -2; + } + + if (vm.count("protocol-map")) { + client->printMap(); + return 0; + } + + client->registerCallback("Default", &receivedPacket); + + client->login(firstName, lastName, password, "00:00:00:00:00:00", 1, 10, 1, 0, "Win", "0", "test_app", + "jhurliman@wsu.edu", loginHandler); + + delete client; + return 0; +} diff --git a/include/Fields.h b/include/Fields.h index 53807220..53c3ad72 100644 --- a/include/Fields.h +++ b/include/Fields.h @@ -7,9 +7,6 @@ * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. * - Neither the name of the Second Life Reverse Engineering Team nor the names * of its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. diff --git a/include/Network.h b/include/Network.h index 285a655c..bbfc1060 100644 --- a/include/Network.h +++ b/include/Network.h @@ -7,9 +7,6 @@ * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. * - Neither the name of the Second Life Reverse Engineering Team nor the names * of its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. diff --git a/include/Packet.h b/include/Packet.h index ce87005c..5f82489e 100644 --- a/include/Packet.h +++ b/include/Packet.h @@ -7,9 +7,6 @@ * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. * - Neither the name of the Second Life Reverse Engineering Team nor the names * of its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. @@ -97,7 +94,8 @@ public: byte* buffer() { return _buffer; }; size_t length() { return _length; }; - + + std::string name() { return _command; }; std::string command() { return _command; }; packetDiagram* layout() { return _layout; }; frequencies::Frequency frequency() { return _frequency; }; diff --git a/include/PacketBuilder.h b/include/PacketBuilder.h index 3d9b2c89..e5dd2cff 100644 --- a/include/PacketBuilder.h +++ b/include/PacketBuilder.h @@ -7,9 +7,6 @@ * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. * - Neither the name of the Second Life Reverse Engineering Team nor the names * of its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. diff --git a/include/ProtocolManager.h b/include/ProtocolManager.h index c6e092f6..ca947f20 100644 --- a/include/ProtocolManager.h +++ b/include/ProtocolManager.h @@ -7,9 +7,6 @@ * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. * - Neither the name of the Second Life Reverse Engineering Team nor the names * of its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. diff --git a/include/SecondLife.h b/include/SecondLife.h index e52d2601..67f0d75b 100644 --- a/include/SecondLife.h +++ b/include/SecondLife.h @@ -7,9 +7,6 @@ * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. * - Neither the name of the Second Life Reverse Engineering Team nor the names * of its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. diff --git a/include/SimConnection.h b/include/SimConnection.h index da77fa46..14ca4848 100644 --- a/include/SimConnection.h +++ b/include/SimConnection.h @@ -7,9 +7,6 @@ * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. * - Neither the name of the Second Life Reverse Engineering Team nor the names * of its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. diff --git a/include/curl/curl.h b/include/curl/curl.h new file mode 100755 index 00000000..143b84ee --- /dev/null +++ b/include/curl/curl.h @@ -0,0 +1,1450 @@ +#ifndef __CURL_CURL_H +#define __CURL_CURL_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2005, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * $Id: curl.h,v 1.287 2005/11/28 23:06:00 bagder Exp $ + ***************************************************************************/ + +/* If you have problems, all libcurl docs and details are found here: + http://curl.haxx.se/libcurl/ +*/ + +#include "curlver.h" /* the libcurl version defines */ + +#include +#include + +/* The include stuff here below is mainly for time_t! */ +#ifdef vms +# include +# include +#else +# include +# include +#endif /* defined (vms) */ + +typedef void CURL; + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Decorate exportable functions for Win32 DLL linking. + * This avoids using a .def file for building libcurl.dll. + */ +#if (defined(WIN32) || defined(_WIN32)) && !defined(CURL_STATICLIB) +#if defined(BUILDING_LIBCURL) +#define CURL_EXTERN __declspec(dllexport) +#else +#define CURL_EXTERN __declspec(dllimport) +#endif +#else +#define CURL_EXTERN +#endif + +/* + * We want the typedef curl_off_t setup for large file support on all + * platforms. We also provide a CURL_FORMAT_OFF_T define to use in *printf + * format strings when outputting a variable of type curl_off_t. + */ + +#if defined(_MSC_VER) || defined(__LCC__) +/* MSVC */ +#ifdef _WIN32_WCE + typedef long curl_off_t; +#define CURL_FORMAT_OFF_T "%ld" +#else + typedef signed __int64 curl_off_t; +#define CURL_FORMAT_OFF_T "%I64d" +#endif +#else /* _MSC_VER || __LCC__ */ +#if (defined(__GNUC__) && defined(WIN32)) || defined(__WATCOMC__) +/* gcc on windows or Watcom */ + typedef long long curl_off_t; +#define CURL_FORMAT_OFF_T "%I64d" +#else /* GCC or Watcom on Windows */ + +/* "normal" POSIX approach, do note that this does not necessarily mean that + the type is >32 bits, see the SIZEOF_CURL_OFF_T define for that! */ + typedef off_t curl_off_t; + +/* Check a range of defines to detect large file support. On Linux it seems + none of these are set by default, so if you don't explicitly switches on + large file support, this define will be made for "small file" support. */ +#ifndef _FILE_OFFSET_BITS +#define _FILE_OFFSET_BITS 0 /* to prevent warnings in the check below */ +#define UNDEF_FILE_OFFSET_BITS +#endif +#ifndef FILESIZEBITS +#define FILESIZEBITS 0 /* to prevent warnings in the check below */ +#define UNDEF_FILESIZEBITS +#endif + +#if defined(_LARGE_FILES) || (_FILE_OFFSET_BITS > 32) || (FILESIZEBITS > 32) \ + || defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE) + /* For now, we assume at least one of these to be set for large files to + work! */ +#define CURL_FORMAT_OFF_T "%lld" +#else /* LARGE_FILE support */ +#define CURL_FORMAT_OFF_T "%ld" +#endif +#endif /* GCC or Watcom on Windows */ +#endif /* _MSC_VER || __LCC__ */ + +#ifdef UNDEF_FILE_OFFSET_BITS +/* this was defined above for our checks, undefine it again */ +#undef _FILE_OFFSET_BITS +#endif + +#ifdef UNDEF_FILESIZEBITS +/* this was defined above for our checks, undefine it again */ +#undef FILESIZEBITS +#endif + +struct curl_httppost { + struct curl_httppost *next; /* next entry in the list */ + char *name; /* pointer to allocated name */ + long namelength; /* length of name length */ + char *contents; /* pointer to allocated data contents */ + long contentslength; /* length of contents field */ + char *buffer; /* pointer to allocated buffer contents */ + long bufferlength; /* length of buffer field */ + char *contenttype; /* Content-Type */ + struct curl_slist* contentheader; /* list of extra headers for this form */ + struct curl_httppost *more; /* if one field name has more than one + file, this link should link to following + files */ + long flags; /* as defined below */ +#define HTTPPOST_FILENAME (1<<0) /* specified content is a file name */ +#define HTTPPOST_READFILE (1<<1) /* specified content is a file name */ +#define HTTPPOST_PTRNAME (1<<2) /* name is only stored pointer + do not free in formfree */ +#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer + do not free in formfree */ +#define HTTPPOST_BUFFER (1<<4) /* upload file from buffer */ +#define HTTPPOST_PTRBUFFER (1<<5) /* upload file from pointer contents */ + + char *showfilename; /* The file name to show. If not set, the + actual file name will be used (if this + is a file part) */ +}; + +typedef int (*curl_progress_callback)(void *clientp, + double dltotal, + double dlnow, + double ultotal, + double ulnow); + + /* Tests have proven that 20K is a very bad buffer size for uploads on + Windows, while 16K for some odd reason performed a lot better. */ +#define CURL_MAX_WRITE_SIZE 16384 + +typedef size_t (*curl_write_callback)(char *buffer, + size_t size, + size_t nitems, + void *outstream); + +/* This is a return code for the read callback that, when returned, will + signal libcurl to immediately abort the current transfer. */ +#define CURL_READFUNC_ABORT 0x10000000 +typedef size_t (*curl_read_callback)(char *buffer, + size_t size, + size_t nitems, + void *instream); + + +#ifndef CURL_NO_OLDIES + /* not used since 7.10.8, will be removed in a future release */ +typedef int (*curl_passwd_callback)(void *clientp, + const char *prompt, + char *buffer, + int buflen); +#endif + +typedef enum { + CURLIOE_OK, /* I/O operation successful */ + CURLIOE_UNKNOWNCMD, /* command was unknown to callback */ + CURLIOE_FAILRESTART, /* failed to restart the read */ + CURLIOE_LAST /* never use */ +} curlioerr; + +typedef enum { + CURLIOCMD_NOP, /* no operation */ + CURLIOCMD_RESTARTREAD, /* restart the read stream from start */ + CURLIOCMD_LAST /* never use */ +} curliocmd; + +typedef curlioerr (*curl_ioctl_callback)(CURL *handle, + int cmd, + void *clientp); + +/* + * The following typedef's are signatures of malloc, free, realloc, strdup and + * calloc respectively. Function pointers of these types can be passed to the + * curl_global_init_mem() function to set user defined memory management + * callback routines. + */ +typedef void *(*curl_malloc_callback)(size_t size); +typedef void (*curl_free_callback)(void *ptr); +typedef void *(*curl_realloc_callback)(void *ptr, size_t size); +typedef char *(*curl_strdup_callback)(const char *str); +typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size); + +/* the kind of data that is passed to information_callback*/ +typedef enum { + CURLINFO_TEXT = 0, + CURLINFO_HEADER_IN, /* 1 */ + CURLINFO_HEADER_OUT, /* 2 */ + CURLINFO_DATA_IN, /* 3 */ + CURLINFO_DATA_OUT, /* 4 */ + CURLINFO_SSL_DATA_IN, /* 5 */ + CURLINFO_SSL_DATA_OUT, /* 6 */ + CURLINFO_END +} curl_infotype; + +typedef int (*curl_debug_callback) + (CURL *handle, /* the handle/transfer this concerns */ + curl_infotype type, /* what kind of data */ + char *data, /* points to the data */ + size_t size, /* size of the data pointed to */ + void *userptr); /* whatever the user please */ + +/* All possible error codes from all sorts of curl functions. Future versions + may return other values, stay prepared. + + Always add new return codes last. Never *EVER* remove any. The return + codes must remain the same! + */ + +typedef enum { + CURLE_OK = 0, + CURLE_UNSUPPORTED_PROTOCOL, /* 1 */ + CURLE_FAILED_INIT, /* 2 */ + CURLE_URL_MALFORMAT, /* 3 */ + CURLE_URL_MALFORMAT_USER, /* 4 (NOT USED) */ + CURLE_COULDNT_RESOLVE_PROXY, /* 5 */ + CURLE_COULDNT_RESOLVE_HOST, /* 6 */ + CURLE_COULDNT_CONNECT, /* 7 */ + CURLE_FTP_WEIRD_SERVER_REPLY, /* 8 */ + CURLE_FTP_ACCESS_DENIED, /* 9 a service was denied by the FTP server + due to lack of access - when login fails + this is not returned. */ + CURLE_FTP_USER_PASSWORD_INCORRECT, /* 10 */ + CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */ + CURLE_FTP_WEIRD_USER_REPLY, /* 12 */ + CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */ + CURLE_FTP_WEIRD_227_FORMAT, /* 14 */ + CURLE_FTP_CANT_GET_HOST, /* 15 */ + CURLE_FTP_CANT_RECONNECT, /* 16 */ + CURLE_FTP_COULDNT_SET_BINARY, /* 17 */ + CURLE_PARTIAL_FILE, /* 18 */ + CURLE_FTP_COULDNT_RETR_FILE, /* 19 */ + CURLE_FTP_WRITE_ERROR, /* 20 */ + CURLE_FTP_QUOTE_ERROR, /* 21 */ + CURLE_HTTP_RETURNED_ERROR, /* 22 */ + CURLE_WRITE_ERROR, /* 23 */ + CURLE_MALFORMAT_USER, /* 24 - NOT USED */ + CURLE_FTP_COULDNT_STOR_FILE, /* 25 - failed FTP upload */ + CURLE_READ_ERROR, /* 26 - could open/read from file */ + CURLE_OUT_OF_MEMORY, /* 27 */ + CURLE_OPERATION_TIMEOUTED, /* 28 - the timeout time was reached */ + CURLE_FTP_COULDNT_SET_ASCII, /* 29 - TYPE A failed */ + CURLE_FTP_PORT_FAILED, /* 30 - FTP PORT operation failed */ + CURLE_FTP_COULDNT_USE_REST, /* 31 - the REST command failed */ + CURLE_FTP_COULDNT_GET_SIZE, /* 32 - the SIZE command failed */ + CURLE_HTTP_RANGE_ERROR, /* 33 - RANGE "command" didn't work */ + CURLE_HTTP_POST_ERROR, /* 34 */ + CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */ + CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */ + CURLE_FILE_COULDNT_READ_FILE, /* 37 */ + CURLE_LDAP_CANNOT_BIND, /* 38 */ + CURLE_LDAP_SEARCH_FAILED, /* 39 */ + CURLE_LIBRARY_NOT_FOUND, /* 40 */ + CURLE_FUNCTION_NOT_FOUND, /* 41 */ + CURLE_ABORTED_BY_CALLBACK, /* 42 */ + CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */ + CURLE_BAD_CALLING_ORDER, /* 44 - NOT USED */ + CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */ + CURLE_BAD_PASSWORD_ENTERED, /* 46 - NOT USED */ + CURLE_TOO_MANY_REDIRECTS , /* 47 - catch endless re-direct loops */ + CURLE_UNKNOWN_TELNET_OPTION, /* 48 - User specified an unknown option */ + CURLE_TELNET_OPTION_SYNTAX , /* 49 - Malformed telnet option */ + CURLE_OBSOLETE, /* 50 - NOT USED */ + CURLE_SSL_PEER_CERTIFICATE, /* 51 - peer's certificate wasn't ok */ + CURLE_GOT_NOTHING, /* 52 - when this is a specific error */ + CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */ + CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as + default */ + CURLE_SEND_ERROR, /* 55 - failed sending network data */ + CURLE_RECV_ERROR, /* 56 - failure in receiving network data */ + CURLE_SHARE_IN_USE, /* 57 - share is in use */ + CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */ + CURLE_SSL_CIPHER, /* 59 - couldn't use specified cipher */ + CURLE_SSL_CACERT, /* 60 - problem with the CA cert (path?) */ + CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized transfer encoding */ + CURLE_LDAP_INVALID_URL, /* 62 - Invalid LDAP URL */ + CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */ + CURLE_FTP_SSL_FAILED, /* 64 - Requested FTP SSL level failed */ + CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind + that failed */ + CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */ + CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not + accepted and we failed to login */ + CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */ + CURLE_TFTP_PERM, /* 69 - permission problem on server */ + CURLE_TFTP_DISKFULL, /* 70 - out of disk space on server */ + CURLE_TFTP_ILLEGAL, /* 71 - Illegal TFTP operation */ + CURLE_TFTP_UNKNOWNID, /* 72 - Unknown transfer ID */ + CURLE_TFTP_EXISTS, /* 73 - File already exists */ + CURLE_TFTP_NOSUCHUSER, /* 74 - No such user */ + CURL_LAST /* never use! */ +} CURLcode; + +typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */ + void *ssl_ctx, /* actually an + OpenSSL SSL_CTX */ + void *userptr); + +/* Make a spelling correction for the operation timed-out define */ +#define CURLE_OPERATION_TIMEDOUT CURLE_OPERATION_TIMEOUTED + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ +/* backwards compatibility with older names */ +#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR +#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED +#endif + +typedef enum { + CURLPROXY_HTTP = 0, + CURLPROXY_SOCKS4 = 4, + CURLPROXY_SOCKS5 = 5 +} curl_proxytype; + +#define CURLAUTH_NONE 0 /* nothing */ +#define CURLAUTH_BASIC (1<<0) /* Basic (default) */ +#define CURLAUTH_DIGEST (1<<1) /* Digest */ +#define CURLAUTH_GSSNEGOTIATE (1<<2) /* GSS-Negotiate */ +#define CURLAUTH_NTLM (1<<3) /* NTLM */ +#define CURLAUTH_ANY ~0 /* all types set */ +#define CURLAUTH_ANYSAFE (~CURLAUTH_BASIC) + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ +/* this was the error code 50 in 7.7.3 and a few earlier versions, this + is no longer used by libcurl but is instead #defined here only to not + make programs break */ +#define CURLE_ALREADY_COMPLETE 99999 + +/* These are just to make older programs not break: */ +#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE +#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME +#endif + +#define CURL_ERROR_SIZE 256 + +/* parameter for the CURLOPT_FTP_SSL option */ +typedef enum { + CURLFTPSSL_NONE, /* do not attempt to use SSL */ + CURLFTPSSL_TRY, /* try using SSL, proceed anyway otherwise */ + CURLFTPSSL_CONTROL, /* SSL for the control connection or fail */ + CURLFTPSSL_ALL, /* SSL for all communication or fail */ + CURLFTPSSL_LAST /* not an option, never use */ +} curl_ftpssl; + +/* parameter for the CURLOPT_FTPSSLAUTH option */ +typedef enum { + CURLFTPAUTH_DEFAULT, /* let libcurl decide */ + CURLFTPAUTH_SSL, /* use "AUTH SSL" */ + CURLFTPAUTH_TLS, /* use "AUTH TLS" */ + CURLFTPAUTH_LAST /* not an option, never use */ +} curl_ftpauth; + +/* long may be 32 or 64 bits, but we should never depend on anything else + but 32 */ +#define CURLOPTTYPE_LONG 0 +#define CURLOPTTYPE_OBJECTPOINT 10000 +#define CURLOPTTYPE_FUNCTIONPOINT 20000 +#define CURLOPTTYPE_OFF_T 30000 + +/* name is uppercase CURLOPT_, + type is one of the defined CURLOPTTYPE_ + number is unique identifier */ +#ifdef CINIT +#undef CINIT +#endif +/* + * Figure out if we can use the ## operator, which is supported by ISO/ANSI C + * and C++. Some compilers support it without setting __STDC__ or __cplusplus + * so we need to carefully check for them too. We don't use configure-checks + * for these since we want these headers to remain generic and working for all + * platforms. + */ +#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ + defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) + /* This compiler is believed to have an ISO compatible preprocessor */ +#define CURL_ISOCPP +#else + /* This compiler is believed NOT to have an ISO compatible preprocessor */ +#undef CURL_ISOCPP +#endif + +#ifdef CURL_ISOCPP +#define CINIT(name,type,number) CURLOPT_ ## name = CURLOPTTYPE_ ## type + number +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define LONG CURLOPTTYPE_LONG +#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT +#define OFF_T CURLOPTTYPE_OFF_T +#define CINIT(name,type,number) CURLOPT_/**/name = type + number +#endif + +/* + * This macro-mania below setups the CURLOPT_[what] enum, to be used with + * curl_easy_setopt(). The first argument in the CINIT() macro is the [what] + * word. + */ + +typedef enum { + /* This is the FILE * or void * the regular output should be written to. */ + CINIT(FILE, OBJECTPOINT, 1), + + /* The full URL to get/put */ + CINIT(URL, OBJECTPOINT, 2), + + /* Port number to connect to, if other than default. */ + CINIT(PORT, LONG, 3), + + /* Name of proxy to use. */ + CINIT(PROXY, OBJECTPOINT, 4), + + /* "name:password" to use when fetching. */ + CINIT(USERPWD, OBJECTPOINT, 5), + + /* "name:password" to use with proxy. */ + CINIT(PROXYUSERPWD, OBJECTPOINT, 6), + + /* Range to get, specified as an ASCII string. */ + CINIT(RANGE, OBJECTPOINT, 7), + + /* not used */ + + /* Specified file stream to upload from (use as input): */ + CINIT(INFILE, OBJECTPOINT, 9), + + /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE + * bytes big. If this is not used, error messages go to stderr instead: */ + CINIT(ERRORBUFFER, OBJECTPOINT, 10), + + /* Function that will be called to store the output (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11), + + /* Function that will be called to read the input (instead of fread). The + * parameters will use fread() syntax, make sure to follow them. */ + CINIT(READFUNCTION, FUNCTIONPOINT, 12), + + /* Time-out the read operation after this amount of seconds */ + CINIT(TIMEOUT, LONG, 13), + + /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about + * how large the file being sent really is. That allows better error + * checking and better verifies that the upload was succcessful. -1 means + * unknown size. + * + * For large file support, there is also a _LARGE version of the key + * which takes an off_t type, allowing platforms with larger off_t + * sizes to handle larger files. See below for INFILESIZE_LARGE. + */ + CINIT(INFILESIZE, LONG, 14), + + /* POST input fields. */ + CINIT(POSTFIELDS, OBJECTPOINT, 15), + + /* Set the referer page (needed by some CGIs) */ + CINIT(REFERER, OBJECTPOINT, 16), + + /* Set the FTP PORT string (interface name, named or numerical IP address) + Use i.e '-' to use default address. */ + CINIT(FTPPORT, OBJECTPOINT, 17), + + /* Set the User-Agent string (examined by some CGIs) */ + CINIT(USERAGENT, OBJECTPOINT, 18), + + /* If the download receives less than "low speed limit" bytes/second + * during "low speed time" seconds, the operations is aborted. + * You could i.e if you have a pretty high speed connection, abort if + * it is less than 2000 bytes/sec during 20 seconds. + */ + + /* Set the "low speed limit" */ + CINIT(LOW_SPEED_LIMIT, LONG , 19), + + /* Set the "low speed time" */ + CINIT(LOW_SPEED_TIME, LONG, 20), + + /* Set the continuation offset. + * + * Note there is also a _LARGE version of this key which uses + * off_t types, allowing for large file offsets on platforms which + * use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE. + */ + CINIT(RESUME_FROM, LONG, 21), + + /* Set cookie in request: */ + CINIT(COOKIE, OBJECTPOINT, 22), + + /* This points to a linked list of headers, struct curl_slist kind */ + CINIT(HTTPHEADER, OBJECTPOINT, 23), + + /* This points to a linked list of post entries, struct HttpPost */ + CINIT(HTTPPOST, OBJECTPOINT, 24), + + /* name of the file keeping your private SSL-certificate */ + CINIT(SSLCERT, OBJECTPOINT, 25), + + /* password for the SSL-private key, keep this for compatibility */ + CINIT(SSLCERTPASSWD, OBJECTPOINT, 26), + /* password for the SSL private key */ + CINIT(SSLKEYPASSWD, OBJECTPOINT, 26), + + /* send TYPE parameter? */ + CINIT(CRLF, LONG, 27), + + /* send linked-list of QUOTE commands */ + CINIT(QUOTE, OBJECTPOINT, 28), + + /* send FILE * or void * to store headers to, if you use a callback it + is simply passed to the callback unmodified */ + CINIT(WRITEHEADER, OBJECTPOINT, 29), + + /* point to a file to read the initial cookies from, also enables + "cookie awareness" */ + CINIT(COOKIEFILE, OBJECTPOINT, 31), + + /* What version to specifly try to use. + See CURL_SSLVERSION defines below. */ + CINIT(SSLVERSION, LONG, 32), + + /* What kind of HTTP time condition to use, see defines */ + CINIT(TIMECONDITION, LONG, 33), + + /* Time to use with the above condition. Specified in number of seconds + since 1 Jan 1970 */ + CINIT(TIMEVALUE, LONG, 34), + + /* 35 = OBSOLETE */ + + /* Custom request, for customizing the get command like + HTTP: DELETE, TRACE and others + FTP: to use a different list command + */ + CINIT(CUSTOMREQUEST, OBJECTPOINT, 36), + + /* HTTP request, for odd commands like DELETE, TRACE and others */ + CINIT(STDERR, OBJECTPOINT, 37), + + /* 38 is not used */ + + /* send linked-list of post-transfer QUOTE commands */ + CINIT(POSTQUOTE, OBJECTPOINT, 39), + + /* Pass a pointer to string of the output using full variable-replacement + as described elsewhere. */ + CINIT(WRITEINFO, OBJECTPOINT, 40), + + CINIT(VERBOSE, LONG, 41), /* talk a lot */ + CINIT(HEADER, LONG, 42), /* throw the header out too */ + CINIT(NOPROGRESS, LONG, 43), /* shut off the progress meter */ + CINIT(NOBODY, LONG, 44), /* use HEAD to get http document */ + CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 300 */ + CINIT(UPLOAD, LONG, 46), /* this is an upload */ + CINIT(POST, LONG, 47), /* HTTP POST method */ + CINIT(FTPLISTONLY, LONG, 48), /* Use NLST when listing ftp dir */ + + CINIT(FTPAPPEND, LONG, 50), /* Append instead of overwrite on upload! */ + + /* Specify whether to read the user+password from the .netrc or the URL. + * This must be one of the CURL_NETRC_* enums below. */ + CINIT(NETRC, LONG, 51), + + CINIT(FOLLOWLOCATION, LONG, 52), /* use Location: Luke! */ + + CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */ + CINIT(PUT, LONG, 54), /* HTTP PUT */ + + /* 55 = OBSOLETE */ + + /* Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_progress_callback + * prototype defines. */ + CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56), + + /* Data passed to the progress callback */ + CINIT(PROGRESSDATA, OBJECTPOINT, 57), + + /* We want the referer field set automatically when following locations */ + CINIT(AUTOREFERER, LONG, 58), + + /* Port of the proxy, can be set in the proxy string as well with: + "[host]:[port]" */ + CINIT(PROXYPORT, LONG, 59), + + /* size of the POST input data, if strlen() is not good to use */ + CINIT(POSTFIELDSIZE, LONG, 60), + + /* tunnel non-http operations through a HTTP proxy */ + CINIT(HTTPPROXYTUNNEL, LONG, 61), + + /* Set the interface string to use as outgoing network interface */ + CINIT(INTERFACE, OBJECTPOINT, 62), + + /* Set the krb4 security level, this also enables krb4 awareness. This is a + * string, 'clear', 'safe', 'confidential' or 'private'. If the string is + * set but doesn't match one of these, 'private' will be used. */ + CINIT(KRB4LEVEL, OBJECTPOINT, 63), + + /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ + CINIT(SSL_VERIFYPEER, LONG, 64), + + /* The CApath or CAfile used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CINIT(CAINFO, OBJECTPOINT, 65), + + /* 66 = OBSOLETE */ + /* 67 = OBSOLETE */ + + /* Maximum number of http redirects to follow */ + CINIT(MAXREDIRS, LONG, 68), + + /* Pass a long set to 1 to get the date of the requested document (if + possible)! Pass a zero to shut it off. */ + CINIT(FILETIME, LONG, 69), + + /* This points to a linked list of telnet options */ + CINIT(TELNETOPTIONS, OBJECTPOINT, 70), + + /* Max amount of cached alive connections */ + CINIT(MAXCONNECTS, LONG, 71), + + /* What policy to use when closing connections when the cache is filled + up */ + CINIT(CLOSEPOLICY, LONG, 72), + + /* 73 = OBSOLETE */ + + /* Set to explicitly use a new connection for the upcoming transfer. + Do not use this unless you're absolutely sure of this, as it makes the + operation slower and is less friendly for the network. */ + CINIT(FRESH_CONNECT, LONG, 74), + + /* Set to explicitly forbid the upcoming transfer's connection to be re-used + when done. Do not use this unless you're absolutely sure of this, as it + makes the operation slower and is less friendly for the network. */ + CINIT(FORBID_REUSE, LONG, 75), + + /* Set to a file name that contains random data for libcurl to use to + seed the random engine when doing SSL connects. */ + CINIT(RANDOM_FILE, OBJECTPOINT, 76), + + /* Set to the Entropy Gathering Daemon socket pathname */ + CINIT(EGDSOCKET, OBJECTPOINT, 77), + + /* Time-out connect operations after this amount of seconds, if connects + are OK within this time, then fine... This only aborts the connect + phase. [Only works on unix-style/SIGALRM operating systems] */ + CINIT(CONNECTTIMEOUT, LONG, 78), + + /* Function that will be called to store headers (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79), + + /* Set this to force the HTTP request to get back to GET. Only really usable + if POST, PUT or a custom request have been used first. + */ + CINIT(HTTPGET, LONG, 80), + + /* Set if we should verify the Common name from the peer certificate in ssl + * handshake, set 1 to check existence, 2 to ensure that it matches the + * provided hostname. */ + CINIT(SSL_VERIFYHOST, LONG, 81), + + /* Specify which file name to write all known cookies in after completed + operation. Set file name to "-" (dash) to make it go to stdout. */ + CINIT(COOKIEJAR, OBJECTPOINT, 82), + + /* Specify which SSL ciphers to use */ + CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83), + + /* Specify which HTTP version to use! This must be set to one of the + CURL_HTTP_VERSION* enums set below. */ + CINIT(HTTP_VERSION, LONG, 84), + + /* Specificly switch on or off the FTP engine's use of the EPSV command. By + default, that one will always be attempted before the more traditional + PASV command. */ + CINIT(FTP_USE_EPSV, LONG, 85), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ + CINIT(SSLCERTTYPE, OBJECTPOINT, 86), + + /* name of the file keeping your private SSL-key */ + CINIT(SSLKEY, OBJECTPOINT, 87), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ + CINIT(SSLKEYTYPE, OBJECTPOINT, 88), + + /* crypto engine for the SSL-sub system */ + CINIT(SSLENGINE, OBJECTPOINT, 89), + + /* set the crypto engine for the SSL-sub system as default + the param has no meaning... + */ + CINIT(SSLENGINE_DEFAULT, LONG, 90), + + /* Non-zero value means to use the global dns cache */ + CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* To becomeO BSOLETE soon */ + + /* DNS cache timeout */ + CINIT(DNS_CACHE_TIMEOUT, LONG, 92), + + /* send linked-list of pre-transfer QUOTE commands (Wesley Laxton)*/ + CINIT(PREQUOTE, OBJECTPOINT, 93), + + /* set the debug function */ + CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94), + + /* set the data for the debug function */ + CINIT(DEBUGDATA, OBJECTPOINT, 95), + + /* mark this as start of a cookie session */ + CINIT(COOKIESESSION, LONG, 96), + + /* The CApath directory used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CINIT(CAPATH, OBJECTPOINT, 97), + + /* Instruct libcurl to use a smaller receive buffer */ + CINIT(BUFFERSIZE, LONG, 98), + + /* Instruct libcurl to not use any signal/alarm handlers, even when using + timeouts. This option is useful for multi-threaded applications. + See libcurl-the-guide for more background information. */ + CINIT(NOSIGNAL, LONG, 99), + + /* Provide a CURLShare for mutexing non-ts data */ + CINIT(SHARE, OBJECTPOINT, 100), + + /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), + CURLPROXY_SOCKS4 and CURLPROXY_SOCKS5. */ + CINIT(PROXYTYPE, LONG, 101), + + /* Set the Accept-Encoding string. Use this to tell a server you would like + the response to be compressed. */ + CINIT(ENCODING, OBJECTPOINT, 102), + + /* Set pointer to private data */ + CINIT(PRIVATE, OBJECTPOINT, 103), + + /* Set aliases for HTTP 200 in the HTTP Response header */ + CINIT(HTTP200ALIASES, OBJECTPOINT, 104), + + /* Continue to send authentication (user+password) when following locations, + even when hostname changed. This can potentionally send off the name + and password to whatever host the server decides. */ + CINIT(UNRESTRICTED_AUTH, LONG, 105), + + /* Specificly switch on or off the FTP engine's use of the EPRT command ( it + also disables the LPRT attempt). By default, those ones will always be + attempted before the good old traditional PORT command. */ + CINIT(FTP_USE_EPRT, LONG, 106), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_USERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CINIT(HTTPAUTH, LONG, 107), + + /* Set the ssl context callback function, currently only for OpenSSL ssl_ctx + in second argument. The function must be matching the + curl_ssl_ctx_callback proto. */ + CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108), + + /* Set the userdata for the ssl context callback function's third + argument */ + CINIT(SSL_CTX_DATA, OBJECTPOINT, 109), + + /* FTP Option that causes missing dirs to be created on the remote server */ + CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_PROXYUSERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CINIT(PROXYAUTH, LONG, 111), + + /* FTP option that changes the timeout, in seconds, associated with + getting a response. This is different from transfer timeout time and + essentially places a demand on the FTP server to acknowledge commands + in a timely manner. */ + CINIT(FTP_RESPONSE_TIMEOUT, LONG , 112), + + /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to + tell libcurl to resolve names to those IP versions only. This only has + affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */ + CINIT(IPRESOLVE, LONG, 113), + + /* Set this option to limit the size of a file that will be downloaded from + an HTTP or FTP server. + + Note there is also _LARGE version which adds large file support for + platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */ + CINIT(MAXFILESIZE, LONG, 114), + + /* See the comment for INFILESIZE above, but in short, specifies + * the size of the file being uploaded. -1 means unknown. + */ + CINIT(INFILESIZE_LARGE, OFF_T, 115), + + /* Sets the continuation offset. There is also a LONG version of this; + * look above for RESUME_FROM. + */ + CINIT(RESUME_FROM_LARGE, OFF_T, 116), + + /* Sets the maximum size of data that will be downloaded from + * an HTTP or FTP server. See MAXFILESIZE above for the LONG version. + */ + CINIT(MAXFILESIZE_LARGE, OFF_T, 117), + + /* Set this option to the file name of your .netrc file you want libcurl + to parse (using the CURLOPT_NETRC option). If not set, libcurl will do + a poor attempt to find the user's home directory and check for a .netrc + file in there. */ + CINIT(NETRC_FILE, OBJECTPOINT, 118), + + /* Enable SSL/TLS for FTP, pick one of: + CURLFTPSSL_TRY - try using SSL, proceed anyway otherwise + CURLFTPSSL_CONTROL - SSL for the control connection or fail + CURLFTPSSL_ALL - SSL for all communication or fail + */ + CINIT(FTP_SSL, LONG, 119), + + /* The _LARGE version of the standard POSTFIELDSIZE option */ + CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120), + + /* Enable/disable the TCP Nagle algorithm */ + CINIT(TCP_NODELAY, LONG, 121), + + /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + + /* When doing 3rd party transfer, set the source user and password with + this */ + CINIT(SOURCE_USERPWD, OBJECTPOINT, 123), + + /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + + /* When doing 3rd party transfer, set the source pre-quote linked list + of commands with this */ + CINIT(SOURCE_PREQUOTE, OBJECTPOINT, 127), + + /* When doing 3rd party transfer, set the source post-quote linked list + of commands with this */ + CINIT(SOURCE_POSTQUOTE, OBJECTPOINT, 128), + + /* When FTP over SSL/TLS is selected (with CURLOPT_FTP_SSL), this option + can be used to change libcurl's default action which is to first try + "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK + response has been received. + + Available parameters are: + CURLFTPAUTH_DEFAULT - let libcurl decide + CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS + CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL + */ + CINIT(FTPSSLAUTH, LONG, 129), + + CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130), + CINIT(IOCTLDATA, OBJECTPOINT, 131), + + /* To make a 3rd party transfer, set the source URL with this */ + CINIT(SOURCE_URL, OBJECTPOINT, 132), + + /* When doing 3rd party transfer, set the source quote linked list of + commands with this */ + CINIT(SOURCE_QUOTE, OBJECTPOINT, 133), + + /* zero terminated string for pass on to the FTP server when asked for + "account" info */ + CINIT(FTP_ACCOUNT, OBJECTPOINT, 134), + + /* feed cookies into cookie engine */ + CINIT(COOKIELIST, OBJECTPOINT, 135), + + /* ignore Content-Length */ + CINIT(IGNORE_CONTENT_LENGTH, LONG, 136), + + /* Set to non-zero to skip the IP address received in a 227 PASV FTP server + response. Typically used for FTP-SSL purposes but is not restricted to + that. libcurl will then instead use the same IP address it used for the + control connection. */ + CINIT(FTP_SKIP_PASV_IP, LONG, 137), + + /* Select "file method" to use when doing FTP */ + CINIT(FTP_FILEMETHOD, LONG, 138), + + CURLOPT_LASTENTRY /* the last unused */ +} CURLoption; + + /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host + name resolves addresses using more than one IP protocol version, this + option might be handy to force libcurl to use a specific IP version. */ +#define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP + versions that your system allows */ +#define CURL_IPRESOLVE_V4 1 /* resolve to ipv4 addresses */ +#define CURL_IPRESOLVE_V6 2 /* resolve to ipv6 addresses */ + + /* three convenient "aliases" that follow the name scheme better */ +#define CURLOPT_WRITEDATA CURLOPT_FILE +#define CURLOPT_READDATA CURLOPT_INFILE +#define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ +#define CURLOPT_HTTPREQUEST -1 +#define CURLOPT_FTPASCII CURLOPT_TRANSFERTEXT +#define CURLOPT_MUTE -2 +#define CURLOPT_PASSWDFUNCTION -3 +#define CURLOPT_PASSWDDATA -4 +#define CURLOPT_CLOSEFUNCTION -5 + +#define CURLOPT_SOURCE_HOST -6 +#define CURLOPT_SOURCE_PATH -7 +#define CURLOPT_SOURCE_PORT -8 +#define CURLOPT_PASV_HOST -9 + +#else +/* This is set if CURL_NO_OLDIES is defined at compile-time */ +#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */ +#endif + + + /* These enums are for use with the CURLOPT_HTTP_VERSION option. */ +enum { + CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd + like the library to choose the best possible + for us! */ + CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */ + CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */ + + CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */ +}; + + /* These enums are for use with the CURLOPT_NETRC option. */ +enum CURL_NETRC_OPTION { + CURL_NETRC_IGNORED, /* The .netrc will never be read. + * This is the default. */ + CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred + * to one in the .netrc. */ + CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored. + * Unless one is set programmatically, the .netrc + * will be queried. */ + CURL_NETRC_LAST +}; + +enum { + CURL_SSLVERSION_DEFAULT, + CURL_SSLVERSION_TLSv1, + CURL_SSLVERSION_SSLv2, + CURL_SSLVERSION_SSLv3, + + CURL_SSLVERSION_LAST /* never use, keep last */ +}; + + +typedef enum { + CURL_TIMECOND_NONE, + + CURL_TIMECOND_IFMODSINCE, + CURL_TIMECOND_IFUNMODSINCE, + CURL_TIMECOND_LASTMOD, + + CURL_TIMECOND_LAST +} curl_TimeCond; + +#ifdef __BEOS__ +#include +#endif + + +/* curl_strequal() and curl_strnequal() are subject for removal in a future + libcurl, see lib/README.curlx for details */ +CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2); +CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n); + +/* name is uppercase CURLFORM_ */ +#ifdef CFINIT +#undef CFINIT +#endif + +#ifdef CURL_ISOCPP +#define CFINIT(name) CURLFORM_ ## name +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define CFINIT(name) CURLFORM_/**/name +#endif + +typedef enum { + CFINIT(NOTHING), /********* the first one is unused ************/ + + /* */ + CFINIT(COPYNAME), + CFINIT(PTRNAME), + CFINIT(NAMELENGTH), + CFINIT(COPYCONTENTS), + CFINIT(PTRCONTENTS), + CFINIT(CONTENTSLENGTH), + CFINIT(FILECONTENT), + CFINIT(ARRAY), + CFINIT(OBSOLETE), + CFINIT(FILE), + + CFINIT(BUFFER), + CFINIT(BUFFERPTR), + CFINIT(BUFFERLENGTH), + + CFINIT(CONTENTTYPE), + CFINIT(CONTENTHEADER), + CFINIT(FILENAME), + CFINIT(END), + CFINIT(OBSOLETE2), + + CURLFORM_LASTENTRY /* the last unusued */ +} CURLformoption; + +#undef CFINIT /* done */ + +/* structure to be used as parameter for CURLFORM_ARRAY */ +struct curl_forms { + CURLformoption option; + const char *value; +}; + +/* use this for multipart formpost building */ +/* Returns code for curl_formadd() + * + * Returns: + * CURL_FORMADD_OK on success + * CURL_FORMADD_MEMORY if the FormInfo allocation fails + * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form + * CURL_FORMADD_NULL if a null pointer was given for a char + * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed + * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used + * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error) + * CURL_FORMADD_MEMORY if a HttpPost struct cannot be allocated + * CURL_FORMADD_MEMORY if some allocation for string copying failed. + * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array + * + ***************************************************************************/ +typedef enum { + CURL_FORMADD_OK, /* first, no error */ + + CURL_FORMADD_MEMORY, + CURL_FORMADD_OPTION_TWICE, + CURL_FORMADD_NULL, + CURL_FORMADD_UNKNOWN_OPTION, + CURL_FORMADD_INCOMPLETE, + CURL_FORMADD_ILLEGAL_ARRAY, + CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */ + + CURL_FORMADD_LAST /* last */ +} CURLFORMcode; + +/* + * NAME curl_formadd() + * + * DESCRIPTION + * + * Pretty advanved function for building multi-part formposts. Each invoke + * adds one part that together construct a full post. Then use + * CURLOPT_HTTPPOST to send it off to libcurl. + */ +CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost, + struct curl_httppost **last_post, + ...); + +/* + * NAME curl_formfree() + * + * DESCRIPTION + * + * Free a multipart formpost previously built with curl_formadd(). + */ +CURL_EXTERN void curl_formfree(struct curl_httppost *form); + +/* + * NAME curl_getenv() + * + * DESCRIPTION + * + * Returns a malloc()'ed string that MUST be curl_free()ed after usage is + * complete. DEPRECATED - see lib/README.curlx + */ +CURL_EXTERN char *curl_getenv(const char *variable); + +/* + * NAME curl_version() + * + * DESCRIPTION + * + * Returns a static ascii string of the libcurl version. + */ +CURL_EXTERN char *curl_version(void); + +/* + * NAME curl_escape() + * + * DESCRIPTION + * + * Escapes URL strings (converts all letters consider illegal in URLs to their + * %XX versions). This function returns a new allocated string or NULL if an + * error occurred. + */ +CURL_EXTERN char *curl_escape(const char *string, int length); + +/* + * NAME curl_unescape() + * + * DESCRIPTION + * + * Unescapes URL encoding in strings (converts all %XX codes to their 8bit + * versions). This function returns a new allocated string or NULL if an error + * occurred. + */ +CURL_EXTERN char *curl_unescape(const char *string, int length); + +/* + * NAME curl_free() + * + * DESCRIPTION + * + * Provided for de-allocation in the same translation unit that did the + * allocation. Added in libcurl 7.10 + */ +CURL_EXTERN void curl_free(void *p); + +/* + * NAME curl_global_init() + * + * DESCRIPTION + * + * curl_global_init() should be invoked exactly once for each application that + * uses libcurl + */ +CURL_EXTERN CURLcode curl_global_init(long flags); + +/* + * NAME curl_global_init_mem() + * + * DESCRIPTION + * + * curl_global_init() or curl_global_init_mem() should be invoked exactly once + * for each application that uses libcurl. This function can be used to + * initialize libcurl and set user defined memory management callback + * functions. Users can implement memory management routines to check for + * memory leaks, check for mis-use of the curl library etc. User registered + * callback routines with be invoked by this library instead of the system + * memory management routines like malloc, free etc. + */ +CURL_EXTERN CURLcode curl_global_init_mem(long flags, + curl_malloc_callback m, + curl_free_callback f, + curl_realloc_callback r, + curl_strdup_callback s, + curl_calloc_callback c); + +/* + * NAME curl_global_cleanup() + * + * DESCRIPTION + * + * curl_global_cleanup() should be invoked exactly once for each application + * that uses libcurl + */ +CURL_EXTERN void curl_global_cleanup(void); + +/* linked-list structure for the CURLOPT_QUOTE option (and other) */ +struct curl_slist { + char *data; + struct curl_slist *next; +}; + +/* + * NAME curl_slist_append() + * + * DESCRIPTION + * + * Appends a string to a linked list. If no list exists, it will be created + * first. Returns the new list, after appending. + */ +CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *, + const char *); + +/* + * NAME curl_slist_free_all() + * + * DESCRIPTION + * + * free a previously built curl_slist. + */ +CURL_EXTERN void curl_slist_free_all(struct curl_slist *); + +/* + * NAME curl_getdate() + * + * DESCRIPTION + * + * Returns the time, in seconds since 1 Jan 1970 of the time string given in + * the first argument. The time argument in the second parameter is unused + * and should be set to NULL. + */ +CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused); + +#define CURLINFO_STRING 0x100000 +#define CURLINFO_LONG 0x200000 +#define CURLINFO_DOUBLE 0x300000 +#define CURLINFO_SLIST 0x400000 +#define CURLINFO_MASK 0x0fffff +#define CURLINFO_TYPEMASK 0xf00000 + +typedef enum { + CURLINFO_NONE, /* first, never use this */ + CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1, + CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2, + CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3, + CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4, + CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5, + CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6, + CURLINFO_SIZE_UPLOAD = CURLINFO_DOUBLE + 7, + CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8, + CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9, + CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10, + CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11, + CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12, + CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13, + CURLINFO_FILETIME = CURLINFO_LONG + 14, + CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15, + CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16, + CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17, + CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18, + CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19, + CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20, + CURLINFO_PRIVATE = CURLINFO_STRING + 21, + CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22, + CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23, + CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24, + CURLINFO_OS_ERRNO = CURLINFO_LONG + 25, + CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26, + CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27, + CURLINFO_COOKIELIST = CURLINFO_SLIST + 28, + /* Fill in new entries below here! */ + + CURLINFO_LASTONE = 28 +} CURLINFO; + +/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as + CURLINFO_HTTP_CODE */ +#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE + +typedef enum { + CURLCLOSEPOLICY_NONE, /* first, never use this */ + + CURLCLOSEPOLICY_OLDEST, + CURLCLOSEPOLICY_LEAST_RECENTLY_USED, + CURLCLOSEPOLICY_LEAST_TRAFFIC, + CURLCLOSEPOLICY_SLOWEST, + CURLCLOSEPOLICY_CALLBACK, + + CURLCLOSEPOLICY_LAST /* last, never use this */ +} curl_closepolicy; + +#define CURL_GLOBAL_SSL (1<<0) +#define CURL_GLOBAL_WIN32 (1<<1) +#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32) +#define CURL_GLOBAL_NOTHING 0 +#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL + + +/***************************************************************************** + * Setup defines, protos etc for the sharing stuff. + */ + +/* Different data locks for a single share */ +typedef enum { + CURL_LOCK_DATA_NONE = 0, + /* CURL_LOCK_DATA_SHARE is used internaly to say that + * the locking is just made to change the internal state of the share + * itself. + */ + CURL_LOCK_DATA_SHARE, + CURL_LOCK_DATA_COOKIE, + CURL_LOCK_DATA_DNS, + CURL_LOCK_DATA_SSL_SESSION, + CURL_LOCK_DATA_CONNECT, + CURL_LOCK_DATA_LAST +} curl_lock_data; + +/* Different lock access types */ +typedef enum { + CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */ + CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */ + CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */ + CURL_LOCK_ACCESS_LAST /* never use */ +} curl_lock_access; + +typedef void (*curl_lock_function)(CURL *handle, + curl_lock_data data, + curl_lock_access locktype, + void *userptr); +typedef void (*curl_unlock_function)(CURL *handle, + curl_lock_data data, + void *userptr); + +typedef void CURLSH; + +typedef enum { + CURLSHE_OK, /* all is fine */ + CURLSHE_BAD_OPTION, /* 1 */ + CURLSHE_IN_USE, /* 2 */ + CURLSHE_INVALID, /* 3 */ + CURLSHE_NOMEM, /* out of memory */ + CURLSHE_LAST /* never use */ +} CURLSHcode; + +typedef enum { + CURLSHOPT_NONE, /* don't use */ + CURLSHOPT_SHARE, /* specify a data type to share */ + CURLSHOPT_UNSHARE, /* specify shich data type to stop sharing */ + CURLSHOPT_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */ + CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */ + CURLSHOPT_USERDATA, /* pass in a user data pointer used in the lock/unlock + callback functions */ + CURLSHOPT_LAST /* never use */ +} CURLSHoption; + +CURL_EXTERN CURLSH *curl_share_init(void); +CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...); +CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *); + +/**************************************************************************** + * Structures for querying information about the curl library at runtime. + */ + +typedef enum { + CURLVERSION_FIRST, + CURLVERSION_SECOND, + CURLVERSION_THIRD, + CURLVERSION_LAST /* never actually use this */ +} CURLversion; + +/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by + basicly all programs ever, that want to get version information. It is + meant to be a built-in version number for what kind of struct the caller + expects. If the struct ever changes, we redefine the NOW to another enum + from above. */ +#define CURLVERSION_NOW CURLVERSION_THIRD + +typedef struct { + CURLversion age; /* age of the returned struct */ + const char *version; /* LIBCURL_VERSION */ + unsigned int version_num; /* LIBCURL_VERSION_NUM */ + const char *host; /* OS/host/cpu/machine when configured */ + int features; /* bitmask, see defines below */ + const char *ssl_version; /* human readable string */ + long ssl_version_num; /* not used anymore, always 0 */ + const char *libz_version; /* human readable string */ + /* protocols is terminated by an entry with a NULL protoname */ + const char * const *protocols; + + /* The fields below this were added in CURLVERSION_SECOND */ + const char *ares; + int ares_num; + + /* This field was aded in CURLVERSION_THIRD */ + const char *libidn; +} curl_version_info_data; + +#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */ +#define CURL_VERSION_KERBEROS4 (1<<1) /* kerberos auth is supported */ +#define CURL_VERSION_SSL (1<<2) /* SSL options are present */ +#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */ +#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */ +#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth support */ +#define CURL_VERSION_DEBUG (1<<6) /* built with debug capabilities */ +#define CURL_VERSION_ASYNCHDNS (1<<7) /* asynchronous dns resolves */ +#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth */ +#define CURL_VERSION_LARGEFILE (1<<9) /* supports files bigger than 2GB */ +#define CURL_VERSION_IDN (1<<10) /* International Domain Names support */ +#define CURL_VERSION_SSPI (1<<11) /* SSPI is supported */ + +/* + * NAME curl_version_info() + * + * DESCRIPTION + * + * This function returns a pointer to a static copy of the version info + * struct. See above. + */ +CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion); + +/* + * NAME curl_easy_strerror() + * + * DESCRIPTION + * + * The curl_easy_strerror function may be used to turn a CURLcode value + * into the equivalent human readable error string. This is useful + * for printing meaningful error messages. + */ +CURL_EXTERN const char *curl_easy_strerror(CURLcode); + +/* + * NAME curl_share_strerror() + * + * DESCRIPTION + * + * The curl_share_strerror function may be used to turn a CURLSHcode value + * into the equivalent human readable error string. This is useful + * for printing meaningful error messages. + */ +CURL_EXTERN const char *curl_share_strerror(CURLSHcode); + +#ifdef __cplusplus +} +#endif + +/* unfortunately, the easy.h and multi.h include files need options and info + stuff before they can be included! */ +#include "easy.h" /* nothing in curl is fun without the easy stuff */ +#include "multi.h" + +#endif /* __CURL_CURL_H */ diff --git a/include/curl/curlver.h b/include/curl/curlver.h new file mode 100755 index 00000000..22bf3a66 --- /dev/null +++ b/include/curl/curlver.h @@ -0,0 +1,56 @@ +#ifndef __CURL_CURLVER_H +#define __CURL_CURLVER_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2005, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * $Id: curlver.h,v 1.17 2005/10/14 21:21:52 bagder Exp $ + ***************************************************************************/ + +/* This header file contains nothing but libcurl version info, generated by + a script at release-time. This was made its own header file in 7.11.2 */ + +/* This is the version number of the libcurl package from which this header + file origins: */ +#define LIBCURL_VERSION "7.15.1" + +/* The numeric version number is also available "in parts" by using these + defines: */ +#define LIBCURL_VERSION_MAJOR 7 +#define LIBCURL_VERSION_MINOR 15 +#define LIBCURL_VERSION_PATCH 1 + +/* This is the numeric version of the libcurl version number, meant for easier + parsing and comparions by programs. The LIBCURL_VERSION_NUM define will + always follow this syntax: + + 0xXXYYZZ + + Where XX, YY and ZZ are the main version, release and patch numbers in + hexadecimal (using 8 bits each). All three numbers are always represented + using two digits. 1.2 would appear as "0x010200" while version 9.11.7 + appears as "0x090b07". + + This 6-digit (24 bits) hexadecimal number does not show pre-release number, + and it is always a greater number in a more recent release. It makes + comparisons with greater than and less than work. +*/ +#define LIBCURL_VERSION_NUM 0x070f01 + +#endif /* __CURL_CURLVER_H */ diff --git a/include/curl/easy.h b/include/curl/easy.h new file mode 100755 index 00000000..b5867200 --- /dev/null +++ b/include/curl/easy.h @@ -0,0 +1,81 @@ +#ifndef __CURL_EASY_H +#define __CURL_EASY_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2004, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * $Id: easy.h,v 1.13 2004/11/09 14:02:58 giva Exp $ + ***************************************************************************/ +#ifdef __cplusplus +extern "C" { +#endif + +CURL_EXTERN CURL *curl_easy_init(void); +CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...); +CURL_EXTERN CURLcode curl_easy_perform(CURL *curl); +CURL_EXTERN void curl_easy_cleanup(CURL *curl); + +/* + * NAME curl_easy_getinfo() + * + * DESCRIPTION + * + * Request internal information from the curl session with this function. The + * third argument MUST be a pointer to a long, a pointer to a char * or a + * pointer to a double (as the documentation describes elsewhere). The data + * pointed to will be filled in accordingly and can be relied upon only if the + * function returns CURLE_OK. This function is intended to get used *AFTER* a + * performed transfer, all results from this function are undefined until the + * transfer is completed. + */ +CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...); + + +/* + * NAME curl_easy_duphandle() + * + * DESCRIPTION + * + * Creates a new curl session handle with the same options set for the handle + * passed in. Duplicating a handle could only be a matter of cloning data and + * options, internal state info and things like persistant connections cannot + * be transfered. It is useful in multithreaded applications when you can run + * curl_easy_duphandle() for each new thread to avoid a series of identical + * curl_easy_setopt() invokes in every thread. + */ +CURL_EXTERN CURL* curl_easy_duphandle(CURL *curl); + +/* + * NAME curl_easy_reset() + * + * DESCRIPTION + * + * Re-initializes a CURL handle to the default values. This puts back the + * handle to the same state as it was in when it was just created. + * + * It does keep: live connections, the Session ID cache, the DNS cache and the + * cookies. + */ +CURL_EXTERN void curl_easy_reset(CURL *curl); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/curl/mprintf.h b/include/curl/mprintf.h new file mode 100755 index 00000000..a6a1ef46 --- /dev/null +++ b/include/curl/mprintf.h @@ -0,0 +1,55 @@ +#ifndef __CURL_MPRINTF_H +#define __CURL_MPRINTF_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2004, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * $Id: mprintf.h,v 1.11 2005/12/02 23:23:49 bagder Exp $ + ***************************************************************************/ + +#include +#include /* needed for FILE */ + +#include "curl.h" + +CURL_EXTERN int curl_mprintf(const char *format, ...); +CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...); +CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...); +CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength, const char *format, ...); +CURL_EXTERN int curl_mvprintf(const char *format, va_list args); +CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args); +CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args); +CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format, va_list args); +CURL_EXTERN char *curl_maprintf(const char *format, ...); +CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args); + +#ifdef _MPRINTF_REPLACE +# define printf curl_mprintf +# define fprintf curl_mfprintf +# define sprintf curl_msprintf +# define snprintf curl_msnprintf +# define vprintf curl_mvprintf +# define vfprintf curl_mvfprintf +# define vsprintf curl_mvsprintf +# define vsnprintf curl_mvsnprintf +# define aprintf curl_maprintf +# define vaprintf curl_mvaprintf +#endif + +#endif /* __CURL_MPRINTF_H */ diff --git a/include/curl/multi.h b/include/curl/multi.h new file mode 100755 index 00000000..1f026795 --- /dev/null +++ b/include/curl/multi.h @@ -0,0 +1,341 @@ +#ifndef __CURL_MULTI_H +#define __CURL_MULTI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2005, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * $Id: multi.h,v 1.27 2005/11/28 07:43:53 bagder Exp $ + ***************************************************************************/ +/* + This is an "external" header file. Don't give away any internals here! + + GOALS + + o Enable a "pull" interface. The application that uses libcurl decides where + and when to ask libcurl to get/send data. + + o Enable multiple simultaneous transfers in the same thread without making it + complicated for the application. + + o Enable the application to select() on its own file descriptors and curl's + file descriptors simultaneous easily. + +*/ +#if defined(_WIN32) && !defined(WIN32) +/* Chris Lewis mentioned that he doesn't get WIN32 defined, only _WIN32 so we + make this adjustment to catch this. */ +#define WIN32 1 +#endif + +#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__GNUC__) || \ + defined(__MINGW32__) +#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H)) +/* The check above prevents the winsock2 inclusion if winsock.h already was + included, since they can't co-exist without problems */ +#include +#endif +#else + +/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish + libc5-based Linux systems. Only include it on system that are known to + require it! */ +#if defined(_AIX) || defined(NETWARE) +#include +#endif + +#ifndef _WIN32_WCE +#include +#endif +#include +#include +#endif + +/* + * This header file should not really need to include "curl.h" since curl.h + * itself includes this file and we expect user applications to do #include + * without the need for especially including multi.h. + * + * For some reason we added this include here at one point, and rather than to + * break existing (wrongly written) libcurl applications, we leave it as-is + * but with this warning attached. + */ +#include "curl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void CURLM; + +#ifdef HAVE_CURL_MULTI_SOCKET /* this is not set by anything yet */ + +#ifndef curl_socket_typedef +/* Public socket typedef */ +#ifdef WIN32 +typedef SOCKET curl_socket_t; +#define CURL_SOCKET_BAD INVALID_SOCKET +#else +typedef int curl_socket_t; +#define CURL_SOCKET_BAD -1 +#endif +#define curl_socket_typedef +#endif /* curl_socket_typedef */ + +#endif /* HAVE_CURL_MULTI_SOCKET */ + +typedef enum { + CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() soon */ + CURLM_OK, + CURLM_BAD_HANDLE, /* the passed-in handle is not a valid CURLM handle */ + CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */ + CURLM_OUT_OF_MEMORY, /* if you ever get this, you're in deep sh*t */ + CURLM_INTERNAL_ERROR, /* this is a libcurl bug */ + CURLM_LAST +} CURLMcode; + +typedef enum { + CURLMSG_NONE, /* first, not used */ + CURLMSG_DONE, /* This easy handle has completed. 'result' contains + the CURLcode of the transfer */ + CURLMSG_LAST /* last, not used */ +} CURLMSG; + +struct CURLMsg { + CURLMSG msg; /* what this message means */ + CURL *easy_handle; /* the handle it concerns */ + union { + void *whatever; /* message-specific data */ + CURLcode result; /* return code for transfer */ + } data; +}; +typedef struct CURLMsg CURLMsg; + +/* + * Name: curl_multi_init() + * + * Desc: inititalize multi-style curl usage + * + * Returns: a new CURLM handle to use in all 'curl_multi' functions. + */ +CURL_EXTERN CURLM *curl_multi_init(void); + +/* + * Name: curl_multi_add_handle() + * + * Desc: add a standard curl handle to the multi stack + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle, + CURL *curl_handle); + + /* + * Name: curl_multi_remove_handle() + * + * Desc: removes a curl handle from the multi stack again + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle, + CURL *curl_handle); + + /* + * Name: curl_multi_fdset() + * + * Desc: Ask curl for its fd_set sets. The app can use these to select() or + * poll() on. We want curl_multi_perform() called as soon as one of + * them are ready. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle, + fd_set *read_fd_set, + fd_set *write_fd_set, + fd_set *exc_fd_set, + int *max_fd); + + /* + * Name: curl_multi_perform() + * + * Desc: When the app thinks there's data available for curl it calls this + * function to read/write whatever there is right now. This returns + * as soon as the reads and writes are done. This function does not + * require that there actually is data available for reading or that + * data can be written, it can be called just in case. It returns + * the number of handles that still transfer data in the second + * argument's integer-pointer. + * + * Returns: CURLMcode type, general multi error code. *NOTE* that this only + * returns errors etc regarding the whole multi stack. There might + * still have occurred problems on invidual transfers even when this + * returns OK. + */ +CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle, + int *running_handles); + + /* + * Name: curl_multi_cleanup() + * + * Desc: Cleans up and removes a whole multi stack. It does not free or + * touch any individual easy handles in any way. We need to define + * in what state those handles will be if this function is called + * in the middle of a transfer. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle); + +/* + * Name: curl_multi_info_read() + * + * Desc: Ask the multi handle if there's any messages/informationals from + * the individual transfers. Messages include informationals such as + * error code from the transfer or just the fact that a transfer is + * completed. More details on these should be written down as well. + * + * Repeated calls to this function will return a new struct each + * time, until a special "end of msgs" struct is returned as a signal + * that there is no more to get at this point. + * + * The data the returned pointer points to will not survive calling + * curl_multi_cleanup(). + * + * The 'CURLMsg' struct is meant to be very simple and only contain + * very basic informations. If more involved information is wanted, + * we will provide the particular "transfer handle" in that struct + * and that should/could/would be used in subsequent + * curl_easy_getinfo() calls (or similar). The point being that we + * must never expose complex structs to applications, as then we'll + * undoubtably get backwards compatibility problems in the future. + * + * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out + * of structs. It also writes the number of messages left in the + * queue (after this read) in the integer the second argument points + * to. + */ +CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle, + int *msgs_in_queue); + +/* + * Name: curl_multi_strerror() + * + * Desc: The curl_multi_strerror function may be used to turn a CURLMcode + * value into the equivalent human readable error string. This is + * useful for printing meaningful error messages. + * + * Returns: A pointer to a zero-terminated error message. + */ +CURL_EXTERN const char *curl_multi_strerror(CURLMcode); + +#ifdef HAVE_CURL_MULTI_SOCKET +/* + * Name: curl_multi_socket() and + * curl_multi_socket_all() + * + * Desc: An alternative version of curl_multi_perform() that allows the + * application to pass in one of the file descriptors that have been + * detected to have "action" on them and let libcurl perform. This + * allows libcurl to not have to scan through all possible file + * descriptors to check for this. The app is recommended to pass in + * the 'easy' argument (or set it to CURL_EASY_NONE) to make libcurl + * figure out the internal structure even faster and easier. If the + * easy argument is set to something else than CURL_EASY_NONE, the + * 's' (socket) argument will be ignored by libcurl. + * + * It also informs the application about updates in the socket (file + * descriptor) status by doing none, one or multiple calls to the + * curl_socket_callback. It thus updates the status with changes + * since the previous time this function was used. If 'callback' is + * NULL, no callback will be called. A status change may also be a + * new timeout only, having the same IN/OUT status as before. + * + * If a previous wait for socket action(s) timed out, you should call + * this function with the socket argument set to + * CURL_SOCKET_TIMEOUT. If you want to force libcurl to (re-)check + * all its internal sockets, and call the callback with status for + * all sockets no matter what the previous state is, you call + * curl_multi_socket_all() instead. + * + * curl_multi_perform() is thus the equivalent of calling + * curl_multi_socket_all(handle, NULL, NULL); + * + * IMPLEMENTATION: libcurl will need an internal hash table to map + * socket numbers to internal easy handles for the cases when 'easy' + * is set to CURL_EASY_NONE. + * + * Regarding the timeout argument in the callback: it is the timeout + * (in milliseconds) for waiting on action on this socket (and the + * given time period starts when the callback is called) until you + * should call curl_multi_socket() with the timeout stuff mentioned + * above. If "actions" happens on the socket before the timeout + * happens, remember that the timout timer keeps ticking until told + * otherwise. + * + * The "what" argument has one of five values: + * + * 0 CURL_POLL_NONE (0) - register, not interested in readiness + * 1 CURL_POLL_IN - register, interested in read readiness + * 2 CURL_POLL_OUT - register, interested in write readiness + * 3 CURL_POLL_INOUT - register, interested in both + * 4 CURL_POLL_REMOVE - deregister + */ +#define CURL_POLL_NONE 0 +#define CURL_POLL_IN 1 +#define CURL_POLL_OUT 2 +#define CURL_POLL_INOUT 3 +#define CURL_POLL_REMOVE 4 + +#define CURL_EASY_NONE (CURL *)0 +#define CURL_EASY_TIMEOUT (CURL *)0 +#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD + +typedef int (*curl_socket_callback)(CURL *easy, /* easy handle */ + curl_socket_t s, /* socket */ + int what, /* see above */ + long ms, /* timeout for wait */ + void *userp); /* "private" pointer */ + +CURLMcode curl_multi_socket(CURLM *multi_handle, + curl_socket_t s, + CURL *easy, + curl_socket_callback callback, + void *userp); /* passed to callback */ + +CURLMcode curl_multi_socket_all(CURLM *multi_handle, + curl_socket_callback callback, + void *userp); /* passed to callback */ + +/* + * Name: curl_multi_timeout() + * + * Desc: Returns the maximum number of milliseconds the app is allowed to + * wait before curl_multi_socket() or curl_multi_perform() must be + * called (to allow libcurl's timed events to take place). + * + * Returns: CURLM error code. + */ +CURLMcode curl_multi_timeout(CURLM *multi_handle, long *milliseconds); + +#endif /* HAVE_CURL_MULTI_SOCKET */ + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/include/curl/stdcheaders.h b/include/curl/stdcheaders.h new file mode 100755 index 00000000..024413ac --- /dev/null +++ b/include/curl/stdcheaders.h @@ -0,0 +1,34 @@ +#ifndef __STDC_HEADERS_H +#define __STDC_HEADERS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2004, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + * $Id: stdcheaders.h,v 1.8 2004/01/07 09:19:34 bagder Exp $ + ***************************************************************************/ + +#include + +size_t fread (void *, size_t, size_t, FILE *); +size_t fwrite (const void *, size_t, size_t, FILE *); + +int strcasecmp(const char *, const char *); +int strncasecmp(const char *, const char *, size_t); + +#endif diff --git a/include/curl/types.h b/include/curl/types.h new file mode 100755 index 00000000..d37d6ae9 --- /dev/null +++ b/include/curl/types.h @@ -0,0 +1 @@ +/* not used */ diff --git a/include/includes.h b/include/includes.h index a5d8084c..377f09c4 100644 --- a/include/includes.h +++ b/include/includes.h @@ -7,9 +7,6 @@ * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. * - Neither the name of the Second Life Reverse Engineering Team nor the names * of its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. @@ -49,12 +46,14 @@ #include #include #include -#include #include #include -#include +#ifdef WIN32 +#else +#include +#endif // Global defines #define VERSION "libsecondlife 0.0.2" @@ -82,9 +81,9 @@ int zeroEncode(byte* src, int srclen, byte* dest); // Global logging facility enum LogLevel { - INFO = 0, - WARNING, - ERROR + LOGINFO = 0, + LOGWARNING = 1, + LOGERROR = 2 }; void log(std::string line, LogLevel level); diff --git a/src/Network.cpp b/src/Network.cpp index 956ecc0d..bf995ec6 100644 --- a/src/Network.cpp +++ b/src/Network.cpp @@ -62,12 +62,12 @@ size_t loginReply(void* buffer, size_t size, size_t nmemb, void* userp) } else { std::stringstream message; message << "Network::loginReply(): Unknown login error, dumping server response:\n" << reply; - log(message.str(), ERROR); + log(message.str(), LOGERROR); } } if (login.reason.length()) { - log("Network::loginReply(): Login failed. Reason: " + login.reason + ". Message: " + login.message, WARNING); + log("Network::loginReply(): Login failed. Reason: " + login.reason + ". Message: " + login.message, LOGWARNING); } else { // Set the variables received from login network->session_id((SimpleLLUUID)login.session_id); @@ -99,7 +99,7 @@ void Network::login(std::string firstName, std::string lastName, std::string pas CURL* curl = curl_easy_init(); if (!curl) { - log("Network::login(): curl_easy_init() returned NULL", ERROR); + log("Network::login(): curl_easy_init() returned NULL", LOGERROR); // Synthesize the callback to keep the client informed loginReply(NULL, 0, 0, &handler); @@ -161,7 +161,7 @@ void Network::login(std::string firstName, std::string lastName, std::string pas if (response) { std::stringstream message; message << "Network::login(): libcurl error: " << loginError; - log(message.str(), ERROR); + log(message.str(), LOGERROR); // Synthesize the callback to keep the client informed loginReply(NULL, 0, 0, &handler); @@ -176,7 +176,7 @@ int Network::connectSim(boost::asio::ipv4::address ip, unsigned short port, unsi // Check if we are already connected to this sim for (size_t i = 0; i < _connections.size(); i++) { if (ip == _connections[i]->ip() && port == _connections[i]->port()) { - log("Network::connectSim(): Attempting to connect to a sim we're already connected to", WARNING); + log("Network::connectSim(): Attempting to connect to a sim we're already connected to", LOGWARNING); return -1; } } @@ -203,12 +203,12 @@ int Network::connectSim(boost::asio::ipv4::address ip, unsigned short port, unsi #ifdef DEBUG std::stringstream message; message << "Network::connectSim(): Sent " << bytesSent << " byte connection packet"; - log(message.str(), INFO); + log(message.str(), LOGINFO); #endif } catch (boost::asio::error& e) { std::stringstream message; message << "Network::connectSim(): " << e; - log(message.str(), ERROR); + log(message.str(), LOGERROR); return -2; } @@ -241,7 +241,7 @@ void Network::listen(SimConnectionPtr sim) #ifdef DEBUG std::stringstream message; message << "Closed connection to sim " << sim->code(); - log(message.str(), INFO); + log(message.str(), LOGINFO); #endif } @@ -314,7 +314,7 @@ int Network::sendPacket(boost::asio::ipv4::address ip, unsigned short port, Pack } if (!found) { - log("Network::sendPacket(): Trying to send a packet to a sim we're not connected to", ERROR); + log("Network::sendPacket(): Trying to send a packet to a sim we're not connected to", LOGERROR); return -1; } @@ -341,7 +341,7 @@ int Network::sendPacket(boost::asio::ipv4::address ip, unsigned short port, Pack } catch (boost::asio::error& e) { std::stringstream message; message << "Network::sendPacket(): " << e << " (1)"; - log(message.str(), ERROR); + log(message.str(), LOGERROR); return -2; } @@ -352,7 +352,7 @@ int Network::sendPacket(boost::asio::ipv4::address ip, unsigned short port, Pack } catch (boost::asio::error& e) { std::stringstream message; message << "Network::sendPacket(): " << e << " (2)"; - log(message.str(), ERROR); + log(message.str(), LOGERROR); return -3; } @@ -361,7 +361,7 @@ int Network::sendPacket(boost::asio::ipv4::address ip, unsigned short port, Pack #ifdef DEBUG std::stringstream message; message << "Network::sendPacket(): Sent " << sent << " byte " << packet->command() << " datagram"; - log(message.str(), INFO); + log(message.str(), LOGINFO); #endif return 0; @@ -370,7 +370,7 @@ int Network::sendPacket(boost::asio::ipv4::address ip, unsigned short port, Pack int Network::sendPacket(PacketPtr packet) { if (!_currentSim) { - log("Network::sendPacket() called when there is no current sim", ERROR); + log("Network::sendPacket() called when there is no current sim", LOGERROR); return -1; } diff --git a/src/Packet.cpp b/src/Packet.cpp index 1c3802f2..16aef8a0 100644 --- a/src/Packet.cpp +++ b/src/Packet.cpp @@ -24,9 +24,9 @@ BlockContainer::BlockContainer(ProtocolManager* protocol, std::string command, s } } - log("BlockContainer::BlockContainer(): Block lookup: " + blockName + ", failed in command: " + command, ERROR); + log("BlockContainer::BlockContainer(): Block lookup: " + blockName + ", failed in command: " + command, LOGERROR); } else { - log("BlockContainer::BlockContainer(): Command lookup failed: " + command, ERROR); + log("BlockContainer::BlockContainer(): Command lookup failed: " + command, LOGERROR); } }*/ @@ -39,7 +39,7 @@ Packet::Packet(std::string command, ProtocolManager* protocol) _layout = _protocol->command(_command); if (!_layout) { - log("Packet::Packet(): Initializing with invalid command: \"" + _command + "\"", ERROR); + log("Packet::Packet(): Initializing with invalid command: \"" + _command + "\"", LOGERROR); _buffer = NULL; _length = 0; return; @@ -68,12 +68,12 @@ Packet::Packet(std::string command, ProtocolManager* protocol) _length = 5; break; case frequencies::Invalid: - log("Packet::Packet(): Command \"" + _command + "\" has an invalid frequency", ERROR); + log("Packet::Packet(): Command \"" + _command + "\" has an invalid frequency", LOGERROR); _buffer = NULL; _length = 0; return; default: - log("Packet::Packet(): Command \"" + _command + "\" has an unknown frequency", ERROR); + log("Packet::Packet(): Command \"" + _command + "\" has an unknown frequency", LOGERROR); _buffer = NULL; _length = 0; return; @@ -88,7 +88,7 @@ Packet::Packet(byte* buffer, size_t length, ProtocolManager* protocol) _buffer = (byte*)malloc(length); if (!_buffer) { - log("Packet::Packet(): malloc() failed", ERROR); + log("Packet::Packet(): malloc() failed", LOGERROR); _length = 0; return; } @@ -121,7 +121,7 @@ Packet::Packet(byte* buffer, size_t length, ProtocolManager* protocol) _command = _protocol->commandString(command, frequencies::High); } } else { - log("Received a datagram less than five bytes", WARNING); + log("Received a datagram less than five bytes", LOGWARNING); } } @@ -134,10 +134,10 @@ void Packet::payload(byte* payload, size_t payloadLength) memcpy(_buffer + _length, payload, payloadLength); _length += payloadLength; } else { - log("Packet::payload(): realloc() failed", ERROR); + log("Packet::payload(): realloc() failed", LOGERROR); } } else { - log("Packet::payload(): Attempting to append a payload to a packet with a null buffer", ERROR); + log("Packet::payload(): Attempting to append a payload to a packet with a null buffer", LOGERROR); } } @@ -152,7 +152,7 @@ void Packet::flags(unsigned short flags) if (_buffer && _length > 2) { memcpy(_buffer, &flags, 2); } else { - log("Packet::flags(): Null or too short buffer", ERROR); + log("Packet::flags(): Null or too short buffer", LOGERROR); } } @@ -168,7 +168,7 @@ void Packet::sequence(unsigned short sequence) sequence = htons(sequence); memcpy(_buffer + 2, &sequence, 2); } else { - log("Packet::sequence(): Null or too short buffer", ERROR); + log("Packet::sequence(): Null or too short buffer", LOGERROR); } } @@ -183,13 +183,13 @@ size_t Packet::headerLength() case frequencies::High: return 5; case frequencies::Invalid: - log("Packet::headerLength(): Invalid frequency", ERROR); + log("Packet::headerLength(): Invalid frequency", LOGERROR); break; default: - log("Packet::headerLength(): Unknown frequency", ERROR); + log("Packet::headerLength(): Unknown frequency", LOGERROR); } } else { - log("Packet::headerLength(): layout is NULL", ERROR); + log("Packet::headerLength(): layout is NULL", LOGERROR); } return 0; @@ -235,7 +235,7 @@ BlockList Packet::getBlocks() blockCount = _buffer[pos]; pos++; } else { - log("Packet::getBlocks(): goto 1 reached", WARNING); + log("Packet::getBlocks(): goto 1 reached", LOGWARNING); goto done; } } else { @@ -254,10 +254,17 @@ BlockList Packet::getBlocks() if ((*fieldMap)->type == types::Variable) { if (pos < _length) { - fieldSize = _buffer[pos]; - pos++; + if ((*fieldMap)->count == 1) { + fieldSize = _buffer[pos]; + pos++; + } else if ((*fieldMap)->count == 2) { + fieldSize = *(unsigned short*)(_buffer + pos); + pos += 2; + } else { + log("Packet::getBlocks(): Abnormally sized Variable field", LOGWARNING); + } } else { - log("Packet::getBlocks(): goto 2 reached", WARNING); + log("Packet::getBlocks(): goto 2 reached", LOGWARNING); goto done; } } else { @@ -270,7 +277,7 @@ BlockList Packet::getBlocks() pos += fieldSize; } else { - log("Packet::getBlocks(): goto 3 reached", WARNING); + log("Packet::getBlocks(): goto 3 reached", LOGWARNING); goto done; } } @@ -376,24 +383,24 @@ done: blockPtr->push_back(fieldPtr); pos += fieldSize; } else { - log("Reached the end of the packet before the end of the map (1)", WARNING); + log("Reached the end of the packet before the end of the map (1)", LOGWARNING); goto done; } } } } else { - //log("Reached the end of the packet before the end of the map (2)", WARNING); + //log("Reached the end of the packet before the end of the map (2)", LOGWARNING); goto done; } } } } else { - log("Reached the end of the packet before the end of the map (3)", WARNING); + log("Reached the end of the packet before the end of the map (3)", LOGWARNING); goto done; } } } else { - log("Packet::unserialize(): Trying to unserialize a packet with no layout", ERROR); + log("Packet::unserialize(): Trying to unserialize a packet with no layout", LOGERROR); } done: diff --git a/src/ProtocolManager.cpp b/src/ProtocolManager.cpp index e4266588..7fe0f51b 100644 --- a/src/ProtocolManager.cpp +++ b/src/ProtocolManager.cpp @@ -91,13 +91,13 @@ FieldPtr createField(packetField* field, byte* data) fieldPtr.reset(new IPPORT(data)); break; case types::Variable: - log("Packet::createField(): Variable type", ERROR); + log("Packet::createField(): Variable type", LOGERROR); break; case types::Invalid: - log("Packet::createField(): Invalid type", ERROR); + log("Packet::createField(): Invalid type", LOGERROR); break; default: - log("Packet::createField(): Unknown type", ERROR); + log("Packet::createField(): Unknown type", LOGERROR); break; } @@ -206,7 +206,8 @@ void ProtocolManager::printMap() printf("\t%04u %s (%02i)\n", (*j)->keywordPosition, (*j)->name.c_str(), (*j)->count); for (k = (*j)->fields.begin(); k != (*j)->fields.end(); ++k) { - printf("\t\t%04u %s (%s)\n", (*k)->keywordPosition, (*k)->name.c_str(), typeName((*k)->type).c_str()); + printf("\t\t%04u %s (%s / %u)\n", (*k)->keywordPosition, (*k)->name.c_str(), + typeName((*k)->type).c_str(), (*k)->count); } } } @@ -222,7 +223,8 @@ void ProtocolManager::printMap() printf("\t%04u %s (%02i)\n", (*j)->keywordPosition, (*j)->name.c_str(), (*j)->count); for (k = (*j)->fields.begin(); k != (*j)->fields.end(); ++k) { - printf("\t\t%04u %s (%s)\n", (*k)->keywordPosition, (*k)->name.c_str(), typeName((*k)->type).c_str()); + printf("\t\t%04u %s (%s / %u)\n", (*k)->keywordPosition, (*k)->name.c_str(), + typeName((*k)->type).c_str(), (*k)->count); } } } @@ -238,7 +240,8 @@ void ProtocolManager::printMap() printf("\t%04u %s (%02i)\n", (*j)->keywordPosition, (*j)->name.c_str(), (*j)->count); for (k = (*j)->fields.begin(); k != (*j)->fields.end(); ++k) { - printf("\t\t%04u %s (%s)\n", (*k)->keywordPosition, (*k)->name.c_str(), typeName((*k)->type).c_str()); + printf("\t\t%04u %s (%s / %u)\n", (*k)->keywordPosition, (*k)->name.c_str(), + typeName((*k)->type).c_str(), (*k)->count); } } } @@ -254,7 +257,7 @@ bool ProtocolManager::getFields(packetBlock* block, std::string protocolMap, siz while(getBlockMarkers(protocolMap.c_str(), fieldStart, fieldEnd, children)) { if (children) { - log("ProtocolManager::getFields(): Found fourth tier elements", ERROR); + log("ProtocolManager::getFields(): Found fourth tier elements", LOGERROR); return false; } @@ -264,7 +267,7 @@ bool ProtocolManager::getFields(packetBlock* block, std::string protocolMap, siz size_t delimiter = temp.find_first_of(" "); if (delimiter == std::string::npos) { - log("ProtocolManager::getFields(): Couldn't parse field: " + temp, ERROR); + log("ProtocolManager::getFields(): Couldn't parse field: " + temp, LOGERROR); return false; } @@ -276,7 +279,7 @@ bool ProtocolManager::getFields(packetBlock* block, std::string protocolMap, siz temp = temp.substr(delimiter + 1, temp.length() - delimiter - 1); - // Get the field type + // Get the field count delimiter = temp.find_first_of(" "); if (delimiter != std::string::npos) { field->count = atoi(temp.substr(delimiter + 1, temp.length() - delimiter - 1).c_str()); @@ -284,6 +287,8 @@ bool ProtocolManager::getFields(packetBlock* block, std::string protocolMap, siz } else { field->count = 1; } + + // Get the field type field->type = fieldType(temp); // Add this field to the linked list @@ -361,7 +366,7 @@ int ProtocolManager::loadKeywords(std::string filename) int i = 0; if (!input.is_open()) { - log("ProtocolManager::loadKeywords(): Error opening keyword file: " + filename, ERROR); + log("ProtocolManager::loadKeywords(): Error opening keyword file: " + filename, LOGERROR); return -1; } @@ -383,13 +388,13 @@ int ProtocolManager::decryptCommFile(std::string source, std::string destination FILE* commFile = fopen(source.c_str(), "rb"); if (!commFile) { - log("ProtocolManager::decryptCommFile(): Couldn't open comm file: " + source, ERROR); + log("ProtocolManager::decryptCommFile(): Couldn't open comm file: " + source, LOGERROR); return -1; } FILE* output = fopen(destination.c_str(), "wb"); if (!output) { - log("ProtocolManager::decryptCommFile(): Couldn't open output file: " + destination, ERROR); + log("ProtocolManager::decryptCommFile(): Couldn't open output file: " + destination, LOGERROR); return -2; } @@ -416,7 +421,7 @@ int ProtocolManager::keywordPosition(std::string keyword) result = _keywordMap.find(keyword); if (result == _keywordMap.end()) { - log("ProtocolManager::keywordPosition(): Couldn't find keyword: " + keyword, WARNING); + log("ProtocolManager::keywordPosition(): Couldn't find keyword: " + keyword, LOGWARNING); return -1; } @@ -439,7 +444,7 @@ int ProtocolManager::buildProtocolMap(std::string filename) FILE* input = fopen(filename.c_str(), "rb"); if (!input) { - log("ProtocolManager::buildProtocolMap(): Couldn't open output file: " + filename, ERROR); + log("ProtocolManager::buildProtocolMap(): Couldn't open output file: " + filename, LOGERROR); return -1; } @@ -486,7 +491,7 @@ int ProtocolManager::buildProtocolMap(std::string filename) layout->frequency = frequencies::High; high++; } else { - log("ProtocolManager::buildProtocolMap(): Unknown frequency: " + temp, ERROR); + log("ProtocolManager::buildProtocolMap(): Unknown frequency: " + temp, LOGERROR); // Increment our position in protocol map cmdStart = cmdEnd + 1; @@ -549,7 +554,7 @@ packetDiagram* ProtocolManager::command(unsigned short command, frequencies::Fre break; } - log("ProtocolManager::command(): Invalid frequency passed in", WARNING); + log("ProtocolManager::command(): Invalid frequency passed in", LOGWARNING); return NULL; } @@ -569,7 +574,7 @@ std::string ProtocolManager::commandString(unsigned short command, frequencies:: break; } - log("ProtocolManager::commandString(): Invalid frequency passed in", WARNING); + log("ProtocolManager::commandString(): Invalid frequency passed in", LOGWARNING); return ""; } @@ -585,7 +590,7 @@ types::Type ProtocolManager::fieldType(std::string type) i++; } - log("ProtocolManager::fieldType(): Unknown type: " + type, WARNING); + log("ProtocolManager::fieldType(): Unknown type: " + type, LOGWARNING); return types::Invalid; } @@ -594,7 +599,7 @@ int ProtocolManager::typeSize(types::Type type) if (type < 0 || type > 19) { std::stringstream message; message << "ProtocolManager::typeSize(): Unknown type: " << type; - log(message.str(), WARNING); + log(message.str(), LOGWARNING); return 0; } @@ -609,7 +614,7 @@ std::string ProtocolManager::typeName(types::Type type) if (type < 0 || type > 19) { std::stringstream message; message << "ProtocolManager::typeName(): Unknown type: " << type; - log(message.str(), WARNING); + log(message.str(), LOGWARNING); typeName = "Invalid"; } else { @@ -629,7 +634,7 @@ int ProtocolManager::blockCount(packetDiagram* layout, std::string block) } } - log("ProtocolManager::blockCount(): Unknown block: " + block, WARNING); + log("ProtocolManager::blockCount(): Unknown block: " + block, LOGWARNING); return 0; } @@ -638,7 +643,7 @@ size_t ProtocolManager::blockSize(packetDiagram* layout, std::string block) std::list::iterator i; if (!layout) { - log("ProtocolManager::blockSize(): NULL layout passed in", WARNING); + log("ProtocolManager::blockSize(): NULL layout passed in", LOGWARNING); return 0; } @@ -657,7 +662,7 @@ size_t ProtocolManager::blockSize(packetDiagram* layout, std::string block) } } - log("ProtocolManager::blockSize(): Unknown block: " + block, WARNING); + log("ProtocolManager::blockSize(): Unknown block: " + block, LOGWARNING); return 0; } @@ -683,11 +688,11 @@ int ProtocolManager::fieldOffset(packetDiagram* layout, std::string block, std:: // The block didn't have the field we're looking for std::stringstream message; message << "ProtocolManager::fieldOffset(): Couldn't find field: " << field << ", in block: " << block; - log(message.str(), WARNING); + log(message.str(), LOGWARNING); return -1; } } - log("ProtocolManager::fieldOffset(): Couldn't find block: " + block, WARNING); + log("ProtocolManager::fieldOffset(): Couldn't find block: " + block, LOGWARNING); return -2; } diff --git a/src/functions.cpp b/src/functions.cpp index 896f5d87..c5f87473 100644 --- a/src/functions.cpp +++ b/src/functions.cpp @@ -182,14 +182,14 @@ std::string packUUID(std::string uuid) void log(std::string line, LogLevel level) { switch (level) { - case INFO: - line = "INFO: " + line; + case LOGINFO: + line = "LOGINFO: " + line; break; - case WARNING: - line = "WARNING: " + line; + case LOGWARNING: + line = "LOGWARNING: " + line; break; - case ERROR: - line = "ERROR: " + line; + case LOGERROR: + line = "LOGERROR: " + line; } line += "\n"; diff --git a/test_app/Jamfile b/test_app/Jamfile deleted file mode 100644 index 0d72d88c..00000000 --- a/test_app/Jamfile +++ /dev/null @@ -1,6 +0,0 @@ -project test_app - : default-build debug - : build-dir ../bin - ; - -exe test_app : main.cpp ..//secondlife ; diff --git a/test_app/main.cpp b/test_app/main.cpp deleted file mode 100644 index 99f78012..00000000 --- a/test_app/main.cpp +++ /dev/null @@ -1,132 +0,0 @@ -#include "SecondLife.h" -#include -#include - -SecondLife* client; - -void loginHandler(loginParameters login) -{ - if (login.reason.length()) { - printf("test_app: Login failed\n"); - } else { - PacketPtr packetPtr = DirLandQuery(client->protocol(), false, true, SimpleLLUUID(1), true, 0, - client->agent_id(), client->session_id()); - client->sendPacket(packetPtr); - - while (1) { - client->tick(); - } - } -} - -/*void writePacket(std::string command, PacketPtr packet) -{ - byte* data = packet->buffer(); - size_t length = packet->length(); - - printf("Wrote packet to file\n"); - - FILE* file = fopen("dirlandreply.dat", "ab"); - fwrite(data, length, 1, file); - fclose(file); -}*/ - -void landPacket(std::string command, PacketPtr packet) -{ - FieldList::iterator field; - BlockList::iterator block; - BlockList blocks = packet->getBlocks(); - bool firstLand; - int area; - bool forSale; - byte* parcelID; - std::string name; - bool auction; - int salePrice; - - for (block = blocks.begin(); block != blocks.end(); ++block) { - if ((*block)->name() == "QueryReplies") { - for (field = (*block)->fields.begin(); field != (*block)->fields.end(); ++field) { - if ((*field)->name() == "ReservedNewbie") { - firstLand = *(*field)->data; - } else if ((*field)->name() == "ActualArea") { - area = *(int*)(*field)->data; - } else if ((*field)->name() == "ForSale") { - forSale = *(*field)->data; - } else if ((*field)->name() == "ParcelID") { - parcelID = (*field)->data; - } else if ((*field)->name() == "Name") { - name = (char*)(*field)->data; - } else if ((*field)->name() == "Auction") { - auction = *(*field)->data; - } else if ((*field)->name() == "SalePrice") { - salePrice = *(int*)(*field)->data; - } - } - - std::cout << name << " | Price: " << salePrice << " | Area: " << area << " | For Sale: " - << forSale << " | Auction: " << auction << std::endl; - } - } -} - -void receivedPacket(std::string command, PacketPtr packet) -{ - /*byte* data = packet->buffer(); - size_t length = packet->length(); - - if (!command.length()) { - printf("test_app: Received foreign datagram:\n"); - - for (size_t i = 0; i < length; i++) { - printf("%02x ", data[i]); - } - printf("\n"); - - return; - } - - printf("test_app: Received a %u byte %s datagram (%u)\n", length, command.c_str(), packet->sequence()); - - return;*/ -} - -int main() -{ - client = new SecondLife(); - - if (client->loadKeywords("keywords.txt") == 0) { - printf("test_app: Loaded keyword file\n"); - } else { - printf("test_app: Failed to load the keyword file\n"); - - delete client; - return -1; - } - - if (client->decryptCommFile("comm.dat", "output.txt") == 0) { - printf("test_app: Decrypted comm file\n"); - } else { - printf("test_app: Failed to decrypt the comm file\n"); - } - - if (client->buildProtocolMap("output.txt") == 0) { - printf("test_app: Built protocol map\n"); - } else { - printf("test_app: Failed to build the protocol map\n"); - - delete client; - return -2; - } - - //client->printMap(); - - client->registerCallback("DirLandReply", &landPacket); - client->registerCallback("Default", &receivedPacket); - - client->login("Chelsea", "Cork", "grapefruit", "00:00:00:00:00:00", 1, 10, 1, 0, "Win", "0", "test_app", - "jhurliman@wsu.edu", loginHandler); - - delete client; - return 0; -}