00001 // 00002 // Clean Content primary C/C++ include file. This is the file that 00003 // should be included in your C or C++ source code 00004 // 00005 00006 00007 00008 00009 #include "commondefs.h" 00010 #include "secureapienums.generated.h" 00011 #include "extracthandler.generated.h" 00012 #include "secureoptions.generated.h" 00013 00014 #ifdef __cplusplus 00015 extern "C" { // only need to export C interface if used by C++ source code 00016 #endif 00017 00018 /// 00019 /// @defgroup init Initialization and threading 00020 /// Functions that control the APIs startup, shutdown and threading behavior 00021 /// @{ 00022 /// 00023 00024 /////////////////////////////////////////////////////////////////////////////// 00025 /// Sets the startup debug feature in a call to BFStartup(). Detailed 00026 /// startup/shutdown information will be printed to STDOUT 00027 /////////////////////////////////////////////////////////////////////////////// 00028 #define BFSTARTUPFEATURE_DEBUG 0x00000001 00029 00030 /////////////////////////////////////////////////////////////////////////////// 00031 /// Sets the log info feature in a call to BFStartup(). Detailed 00032 /// startup/shutdown information, calls to API functions and other interesting 00033 /// information will be logged to STDOUT 00034 /////////////////////////////////////////////////////////////////////////////// 00035 #define BFSTARTUPFEATURE_LOGINFO 0x00000002 00036 00037 /////////////////////////////////////////////////////////////////////////////// 00038 /// Initialize the API. Must be called before calling any other API functions. 00039 /// Must only be called once per process. Call either BFStartup OR 00040 /// BFStartupEx but not both. 00041 /// @param features Any of the BFSTARTUPFEATURE @#defines ORed together 00042 /// @return One of the BFRESULT codes 00043 /////////////////////////////////////////////////////////////////////////////// 00044 BFEXPORT_FUNCDEC int BFStartup(int features); 00045 00046 /////////////////////////////////////////////////////////////////////////////// 00047 /// Initialize the API. Must be called before calling any other API functions. 00048 /// Must only be called once per process. Call either BFStartup OR 00049 /// BFStartupEx but not both. 00050 /// @param features Any of the BFSTARTUPFEATURE @#defines ORed together 00051 /// @param jarPath Full path to the directory containing CleanContent.jar. 00052 /// If this paramter is not NULL, it overrides both the standard jar search 00053 /// and the BITFORM_JARPATH environment variable. 00054 /// @param jrePath Full path to the Java Runtime Environment. If this paramter 00055 /// is not NULL, it overrides both the standard JRE search and the 00056 /// BITFORM_JREPATH environment variable. 00057 /// @param jreOptions An array of option strings to pass to the JVM on startup. 00058 /// If this parameter is not NULL it overrides Clean Content's default JVM options. 00059 /// The strings are in the form of full arguments to the JVM, for example 00060 /// "-Xmx1024M", "-Xrs", etc. If this parameter is NULL, Clean Content will use its 00061 /// (very conservative) defaults of -Xmx400M and -XX:MaxPermSize=128M. 00062 /// If this parameter is an empty array, and jreOptionsLen is set to 0, 00063 /// the JVM will use it's own defaults. 00064 /// @param jreOptionsLen The count of strings in the options array. 40 is the maximum 00065 /// number allowed. 00066 /// @param jreOptionsIgnoreUnknown If not equal to 0, the JRE will ignore options 00067 /// it doesn't understand. If equal to 0, JRE loading will fail if it doesn't understand 00068 /// all the options. 00069 /// 00070 /// @return One of the BFRESULT codes 00071 /////////////////////////////////////////////////////////////////////////////// 00072 BFEXPORT_FUNCDEC int BFStartupEx(int features, char * jarPath, char * jrePath, char * jreOptions[], int jreOptionsLen, int jreOptionsIgnoreUnknown); 00073 00074 /////////////////////////////////////////////////////////////////////////////// 00075 /// Clean up the API. Must be called after all use of this API is complete. 00076 /// Must be called from the same thread that called BFStartup(). 00077 /////////////////////////////////////////////////////////////////////////////// 00078 BFEXPORT_FUNCDEC void BFShutdown(); 00079 00080 /////////////////////////////////////////////////////////////////////////////// 00081 /// Start using this API in a new thread. Must be called for each new thread 00082 /// that will use this API, not including the thread in which BFStartup() is 00083 /// called. Threads that call this function must call BFDetachThread() before 00084 /// BFShutdown() is called. 00085 /////////////////////////////////////////////////////////////////////////////// 00086 BFEXPORT_FUNCDEC void BFAttachThread(void); 00087 00088 /////////////////////////////////////////////////////////////////////////////// 00089 /// Finish using this API in a thread. Must be called for each thread that 00090 /// called BFAttachThread() after the thread has finished using this API. 00091 /////////////////////////////////////////////////////////////////////////////// 00092 BFEXPORT_FUNCDEC void BFDetachThread(void); 00093 00094 /// 00095 /// @} 00096 /// 00097 00098 /// 00099 /// @defgroup request Request creation and execution 00100 /// Functions that create and execute a request to process a document 00101 /// @{ 00102 /// 00103 00104 /////////////////////////////////////////////////////////////////////////////// 00105 /// Create a secure request. Creates a secure request that can be used to 00106 /// analyze and scrub documents. Secure requests can (and should) be reused 00107 /// within a single thread for processing multiple documents. 00108 /// @param request Pointer to a ::BFHANDLE that will represent the request 00109 /// @param errorinfo Pointer to a handle that will be set to an error information 00110 /// handle if the function's return value is not ::BFRESULT_OK. 00111 /// This parameter may be NULL and may be set to NULL if no error information is available. 00112 /// @return One of the BFRESULT codes 00113 /////////////////////////////////////////////////////////////////////////////// 00114 BFEXPORT_FUNCDEC int BFOpenSecureRequest(BFHANDLE * request, BFHANDLE * errorinfo); 00115 00116 /////////////////////////////////////////////////////////////////////////////// 00117 /// Execute a secure request. Executes a request to analyze or scrub a 00118 /// document. Use the BFSet*Option functions to setup the request before 00119 /// calling this function. 00120 /// @param request ::BFHANDLE that represents the request 00121 /// @param errorinfo Pointer to a handle that will be set to an error information 00122 /// handle if the function's return value is not ::BFRESULT_OK. 00123 /// This parameter may be NULL and may be set to NULL if no error information is available. 00124 /// @return One of the BFRESULT codes 00125 /////////////////////////////////////////////////////////////////////////////// 00126 BFEXPORT_FUNCDEC int BFExecuteSecureRequest(const BFHANDLE request, BFHANDLE * errorinfo); 00127 00128 /////////////////////////////////////////////////////////////////////////////// 00129 /// Gets the response to a request. Used after a call to 00130 /// BFExecuteSecureRequest() to get the results. 00131 /// @param request ::BFHANDLE that represents the request 00132 /// @param response Pointer to a ::BFHANDLE that will represent the response 00133 /// @param errorinfo Pointer to a handle that will be set to an error information 00134 /// handle if the function's return value is not ::BFRESULT_OK. 00135 /// This parameter may be NULL and may be set to NULL if no error information is available. 00136 /// @return One of the BFRESULT codes 00137 /////////////////////////////////////////////////////////////////////////////// 00138 BFEXPORT_FUNCDEC int BFGetSecureResponse(const BFHANDLE request, BFHANDLE * response, BFHANDLE * errorinfo); 00139 00140 /////////////////////////////////////////////////////////////////////////////// 00141 /// Compare two requests. This function is exposed primarily for testing 00142 /// purposes. 00143 /// @param request1 ::BFHANDLE that represents a request 00144 /// @param request2 ::BFHANDLE that represents a request 00145 /// @param errorinfo Pointer to a handle that will be set to an error information 00146 /// handle if the function's return value is not ::BFRESULT_OK. 00147 /// This parameter may be NULL and may be set to NULL if no error information is available. 00148 /// @return ::BFTRUE if the requests contain all the same values, ::BFFALSE otherwise 00149 /////////////////////////////////////////////////////////////////////////////// 00150 BFEXPORT_FUNCDEC int BFCompareRequest(const BFHANDLE request1, const BFHANDLE request2, BFHANDLE * errorinfo); 00151 00152 00153 /////////////////////////////////////////////////////////////////////////////// 00154 /// Destory a secure request. The request should never again be used after 00155 /// this function returns. 00156 /// @param request ::BFHANDLE that represents the request 00157 /// @param errorinfo Pointer to a handle that will be set to an error information 00158 /// handle if the function's return value is not ::BFRESULT_OK. 00159 /// This parameter may be NULL and may be set to NULL if no error information is available. 00160 /// @return One of the BFRESULT codes 00161 /////////////////////////////////////////////////////////////////////////////// 00162 BFEXPORT_FUNCDEC int BFCloseSecureRequest(const BFHANDLE request, BFHANDLE * errorinfo); 00163 00164 00165 /// 00166 /// @} 00167 /// 00168 00169 /// 00170 /// @defgroup options Request options 00171 /// Functions that set and get the options on a request 00172 /// @{ 00173 /// 00174 00175 /////////////////////////////////////////////////////////////////////////////// 00176 /// Sets a scrub option. 00177 /// @param request BFHANDLE that represents the request 00178 /// @param option One of the values in ScrubOptions 00179 /// @param action One of the actions in Actions 00180 /// @param errorinfo Pointer to a handle that will be set to an error information 00181 /// handle if the function's return value is not BFRESULT_OK. 00182 /// This parameter may be NULL and may be set to NULL if no error information is available. 00183 /// @return One of the BFRESULT codes 00184 /////////////////////////////////////////////////////////////////////////////// 00185 BFEXPORT_FUNCDEC int BFSetScrubOption(const BFHANDLE request, const enum ScrubOptions option, const enum ScrubOptionActions action, BFHANDLE * errorinfo); 00186 00187 /////////////////////////////////////////////////////////////////////////////// 00188 /// Sets an analyze option. 00189 /// @param request BFHANDLE that represents the request 00190 /// @param option One of the values in AnalyzeOptions 00191 /// @param action One of the actions in the Actions enum 00192 /// @param errorinfo Pointer to a handle that will be set to an error information 00193 /// handle if the function's return value is not BFRESULT_OK. 00194 /// This parameter may be NULL and may be set to NULL if no error information is available. 00195 /// @return One of the BFRESULT codes 00196 /////////////////////////////////////////////////////////////////////////////// 00197 BFEXPORT_FUNCDEC int BFSetAnalyzeOption(const BFHANDLE request, const enum AnalyzeOptions option, const enum ScrubOptionActions action, BFHANDLE * errorinfo); 00198 00199 00200 /////////////////////////////////////////////////////////////////////////////// 00201 /// Sets a boolean option. 00202 /// @param request BFHANDLE that represents the request 00203 /// @param option One of the values in BooleanOptions 00204 /// @param value BFTRUE or BFFALSE 00205 /// @param errorinfo Pointer to a handle that will be set to an error information 00206 /// handle if the function's return value is not BFRESULT_OK. 00207 /// This parameter may be NULL and may be set to NULL if no error information is available. 00208 /// @return One of the BFRESULT codes 00209 /////////////////////////////////////////////////////////////////////////////// 00210 BFEXPORT_FUNCDEC int BFSetBooleanOption(const BFHANDLE request, const enum BooleanOptions option, const int value, BFHANDLE * errorinfo); 00211 00212 /////////////////////////////////////////////////////////////////////////////// 00213 /// Sets an integer option. 00214 /// @param request BFHANDLE that represents the request 00215 /// @param option One of the values in IntegerOptions 00216 /// @param value the option should take 00217 /// @param errorinfo Pointer to a handle that will be set to an error information 00218 /// handle if the function's return value is not BFRESULT_OK. 00219 /// This parameter may be NULL and may be set to NULL if no error information is available. 00220 /// @return One of the BFRESULT codes 00221 /////////////////////////////////////////////////////////////////////////////// 00222 BFEXPORT_FUNCDEC int BFSetIntegerOption(const BFHANDLE request, const enum IntegerOptions option, const BFINT64 value, BFHANDLE * errorinfo); 00223 00224 00225 /////////////////////////////////////////////////////////////////////////////// 00226 /// Sets an enum option. 00227 /// @param request BFHANDLE that represents the request 00228 /// @param option One of the values in EnumOptions 00229 /// @param value the option should take 00230 /// @param errorinfo Pointer to a handle that will be set to an error information 00231 /// handle if the function's return value is not BFRESULT_OK. 00232 /// This parameter may be NULL and may be set to NULL if no error information is available. 00233 /// @return One of the BFRESULT codes 00234 /////////////////////////////////////////////////////////////////////////////// 00235 BFEXPORT_FUNCDEC int BFSetEnumOption(const BFHANDLE request, const enum EnumOptions option, const int value, BFHANDLE * errorinfo); 00236 00237 /////////////////////////////////////////////////////////////////////////////// 00238 /// Sets an enum list option. 00239 /// @param request BFHANDLE that represents the request 00240 /// @param option One of the values in EnumListOptions 00241 /// @param values An array integers 00242 /// @param count Number of integers in the array 00243 /// @param errorinfo Pointer to a handle that will be set to an error information 00244 /// handle if the function's return value is not BFRESULT_OK. 00245 /// This parameter may be NULL and may be set to NULL if no error information is available. 00246 /// @return One of the BFRESULT codes 00247 /////////////////////////////////////////////////////////////////////////////// 00248 BFEXPORT_FUNCDEC int BFSetEnumListOption(const BFHANDLE request, const enum EnumListOptions option, const int values[], int count, BFHANDLE * errorinfo); 00249 00250 /////////////////////////////////////////////////////////////////////////////// 00251 /// Sets a string option. 00252 /// @param request BFHANDLE that represents the request 00253 /// @param option One of the values in StringOptions 00254 /// @param string pointer to a NULL terminated UNICODE string 00255 /// @param errorinfo Pointer to a handle that will be set to an error information 00256 /// handle if the function's return value is not BFRESULT_OK. 00257 /// This parameter may be NULL and may be set to NULL if no error information is available. 00258 /// @return One of the BFRESULT codes 00259 /////////////////////////////////////////////////////////////////////////////// 00260 BFEXPORT_FUNCDEC int BFSetStringOption(const BFHANDLE request, const enum StringOptions option, const wchar_t * string, BFHANDLE * errorinfo); 00261 00262 /////////////////////////////////////////////////////////////////////////////// 00263 /// Sets a string list option. 00264 /// @param request BFHANDLE that represents the request 00265 /// @param option One of the values in StringListOptions 00266 /// @param strings An array of pointers to a NULL terminated UNICODE strings 00267 /// @param count Number of strings in the array 00268 /// @param errorinfo Pointer to a handle that will be set to an error information 00269 /// handle if the function's return value is not BFRESULT_OK. 00270 /// This parameter may be NULL and may be set to NULL if no error information is available. 00271 /// @return One of the BFRESULT codes 00272 /////////////////////////////////////////////////////////////////////////////// 00273 BFEXPORT_FUNCDEC int BFSetStringListOption(const BFHANDLE request, const enum StringListOptions option, const wchar_t * strings[], int count, BFHANDLE * errorinfo); 00274 00275 /////////////////////////////////////////////////////////////////////////////// 00276 /// Sets a file option using a path to the file. 00277 /// @param request BFHANDLE that represents the request 00278 /// @param option One of the values in FileOptions 00279 /// @param path Pointer to a NULL terminated UNICODE string containing a 00280 /// fully qualified path to the file 00281 /// @param errorinfo Pointer to a handle that will be set to an error information 00282 /// handle if the function's return value is not BFRESULT_OK. 00283 /// This parameter may be NULL and may be set to NULL if no error information is available. 00284 /// @return One of the BFRESULT codes 00285 /////////////////////////////////////////////////////////////////////////////// 00286 BFEXPORT_FUNCDEC int BFSetFileOption(const BFHANDLE request, const enum FileOptions option, const wchar_t * path, BFHANDLE * errorinfo); 00287 00288 /////////////////////////////////////////////////////////////////////////////// 00289 /// Sets a date option. 00290 /// The date information provided is without locale or time zone information. 00291 /// @param request BFHANDLE that represents the request 00292 /// @param option One of the values in DateOptions 00293 /// @param year The year, value is AD 00294 /// @param month The month, value is 0-based where 0 is January 00295 /// @param day Day of the month 00296 /// @param hour Hour 00297 /// @param minute Minute 00298 /// @param second Second 00299 /// @param errorinfo Pointer to a handle that will be set to an error information 00300 /// handle if the function's return value is not BFRESULT_OK. 00301 /// This parameter may be NULL and may be set to NULL if no error information is available. 00302 /// @return One of the BFRESULT codes 00303 /////////////////////////////////////////////////////////////////////////////// 00304 BFEXPORT_FUNCDEC int BFSetDateOption(const BFHANDLE request, const enum DateOptions option, int year, int month, int day, int hour, int minute, int second, BFHANDLE * errorinfo); 00305 00306 /////////////////////////////////////////////////////////////////////////////// 00307 /// Sets a duration option. 00308 /// @param request BFHANDLE that represents the request 00309 /// @param option One of the values in DurationOptions 00310 /// @param duration Duration in milliseconds 00311 /// @param errorinfo Pointer to a handle that will be set to an error information 00312 /// handle if the function's return value is not BFRESULT_OK. 00313 /// This parameter may be NULL and may be set to NULL if no error information is available. 00314 /// @return One of the BFRESULT codes 00315 /////////////////////////////////////////////////////////////////////////////// 00316 BFEXPORT_FUNCDEC int BFSetDurationOption(const BFHANDLE request, const enum DurationOptions option, int duration, BFHANDLE * errorinfo); 00317 00318 /////////////////////////////////////////////////////////////////////////////// 00319 /// Sets a directory option using a path to the directory. 00320 /// @param request BFHANDLE that represents the request 00321 /// @param option One of the values in DirectoryOptions 00322 /// @param path Pointer to a NULL terminated UNICODE string containing a 00323 /// fully qualified path to the directory 00324 /// @param errorinfo Pointer to a handle that will be set to an error information 00325 /// handle if the function's return value is not BFRESULT_OK. 00326 /// This parameter may be NULL and may be set to NULL if no error information is available. 00327 /// @return One of the BFRESULT codes 00328 /////////////////////////////////////////////////////////////////////////////// 00329 BFEXPORT_FUNCDEC int BFSetDirectoryOption(const BFHANDLE request, const enum DirectoryOptions option, const wchar_t * path, BFHANDLE * errorinfo); 00330 00331 /////////////////////////////////////////////////////////////////////////////// 00332 /// Sets a file option using a block of memory. 00333 /// @param request BFHANDLE that represents the request 00334 /// @param option One of the values in FileOptions 00335 /// @param memory A pointer to a block of memory containing the entire file 00336 /// @param length The size of the file in memory 00337 /// @param errorinfo Pointer to a handle that will be set to an error information 00338 /// handle if the function's return value is not BFRESULT_OK. 00339 /// This parameter may be NULL and may be set to NULL if no error information is available. 00340 /// @return One of the BFRESULT codes 00341 /////////////////////////////////////////////////////////////////////////////// 00342 BFEXPORT_FUNCDEC int BFSetFileOptionUsingMemory(const BFHANDLE request, const enum FileOptions option, const void * memory, const long length, BFHANDLE * errorinfo); 00343 00344 /////////////////////////////////////////////////////////////////////////////// 00345 /// The channel can read bytes from the file. Used in return value from 00346 /// BFChannelSupports(). 00347 /////////////////////////////////////////////////////////////////////////////// 00348 #define BFCHANNELCANREAD 0x0001 00349 00350 /////////////////////////////////////////////////////////////////////////////// 00351 /// The channel can write bytes to the file. Used in return value from 00352 /// BFChannelSupports(). 00353 /////////////////////////////////////////////////////////////////////////////// 00354 #define BFCHANNELCANWRITE 0x0002 00355 00356 /////////////////////////////////////////////////////////////////////////////// 00357 /// Pointer to a function that reads bytes from the channel. 00358 /// @param channel A pointer back to the BFCHANNEL structure provided 00359 /// in BFSetFileOptionUsingChannel. 00360 /// @param buffer The buffer to read bytes into 00361 /// @param count Number of bytes to read 00362 /// @param position Offset in the file the bytes should be read at 00363 /// @return The number of bytes actually read. A number less than count or 0 00364 /// means the end of file has been reached. 00365 /////////////////////////////////////////////////////////////////////////////// 00366 typedef long (* BFChannelRead)(void * channel, void * buffer, BFINT32 count, BFINT64 position); 00367 00368 /////////////////////////////////////////////////////////////////////////////// 00369 /// Pointer to a function that writes bytes to the channel. 00370 /// @param channel A pointer back to the BFCHANNEL structure provided 00371 /// in BFSetFileOptionUsingChannel. 00372 /// @param buffer The buffer containing the bytes to write 00373 /// @param count Number of bytes to write 00374 /// @param position Offset in the file the bytes should be written to 00375 /////////////////////////////////////////////////////////////////////////////// 00376 typedef void (* BFChannelWrite)(void * channel, void * buffer, BFINT32 count, BFINT64 position); 00377 00378 /////////////////////////////////////////////////////////////////////////////// 00379 /// Pointer to a function that provides the size of the channel. 00380 /// @param channel A pointer back to the BFCHANNEL structure provided 00381 /// in BFSetFileOptionUsingChannel. 00382 /// @return The number of bytes in the file. 00383 /////////////////////////////////////////////////////////////////////////////// 00384 typedef BFINT64 (* BFChannelSize)(void * channel); 00385 00386 /////////////////////////////////////////////////////////////////////////////// 00387 /// Pointer to a function that returns information about what features this 00388 /// channel supports. 00389 /// @param channel A pointer back to the BFCHANNEL structure provided 00390 /// in BFSetFileOptionUsingChannel. 00391 /// @return BFCHANNELCANREAD, BFCHANNELCANWRITE or both ORed together 00392 /////////////////////////////////////////////////////////////////////////////// 00393 typedef long (* BFChannelSupports)(void * channel); 00394 00395 /////////////////////////////////////////////////////////////////////////////// 00396 /// Pointer to a function that closes the channel. 00397 /// @param channel A pointer back to the BFCHANNEL structure provided 00398 /// in BFSetFileOptionUsingChannel. 00399 /////////////////////////////////////////////////////////////////////////////// 00400 typedef void (* BFChannelClose)(void * channel); 00401 00402 /////////////////////////////////////////////////////////////////////////////// 00403 /// Pointer to a function that truncates the channel to the given size. 00404 /// @param channel A pointer back to the BFCHANNEL structure provided 00405 /// in BFSetFileOptionUsingChannel. 00406 /// @param size Size of the file after truncation 00407 /////////////////////////////////////////////////////////////////////////////// 00408 typedef void (* BFChannelTruncate)(void * channel, BFINT64 size); 00409 00410 /////////////////////////////////////////////////////////////////////////////// 00411 /// Structure used to redirect the IO. The developer fills in this structure 00412 /// and passes it to SetFileOptionUsingChannel() in order to control the IO 00413 /// for a given value of FileOptions, most commonly the 00414 /// SourceDocument option. It is common for developers to define their own 00415 /// struct that begins with an instance of BFCHANNEL and then includes any 00416 /// data they would like to pass through to the read, write, etc. functions. 00417 /////////////////////////////////////////////////////////////////////////////// 00418 typedef struct _BFCHANNEL { 00419 /////////////////////////////////////////////////////////////////////////////// 00420 /// Pointer to a function that reads bytes from the channel. 00421 /////////////////////////////////////////////////////////////////////////////// 00422 BFChannelRead read; 00423 /////////////////////////////////////////////////////////////////////////////// 00424 /// Pointer to a function that writes bytes to the channel. 00425 /////////////////////////////////////////////////////////////////////////////// 00426 BFChannelWrite write; 00427 /////////////////////////////////////////////////////////////////////////////// 00428 /// Pointer to a function that returns the channel's size in bytes. 00429 /////////////////////////////////////////////////////////////////////////////// 00430 BFChannelSize size; 00431 /////////////////////////////////////////////////////////////////////////////// 00432 /// Pointer to a function that returns information about what features this 00433 /// channel supports. 00434 /////////////////////////////////////////////////////////////////////////////// 00435 BFChannelSupports supports; 00436 /////////////////////////////////////////////////////////////////////////////// 00437 /// Pointer to a function that closes the channel. 00438 /////////////////////////////////////////////////////////////////////////////// 00439 BFChannelClose close; 00440 /////////////////////////////////////////////////////////////////////////////// 00441 /// Pointer to a function that truncates the channel. 00442 /////////////////////////////////////////////////////////////////////////////// 00443 BFChannelTruncate truncate; 00444 /////////////////////////////////////////////////////////////////////////////// 00445 /// Reserved for internal use. 00446 /////////////////////////////////////////////////////////////////////////////// 00447 BFINT32 reserved; 00448 } BFCHANNEL; 00449 00450 /////////////////////////////////////////////////////////////////////////////// 00451 /// Sets a file option using a set of callbacks routines. 00452 /// @param request BFHANDLE that represents the request 00453 /// @param option One of the values in FileOptions 00454 /// @param channel Pointer to a BFCHANNEL structure contained read, write and other 00455 /// IO routines supplied your code 00456 /// @param errorinfo Pointer to a handle that will be set to an error information 00457 /// handle if the function's return value is not BFRESULT_OK. 00458 /// This parameter may be NULL and may be set to NULL if no error information is available. 00459 /// @return One of the BFRESULT codes 00460 /////////////////////////////////////////////////////////////////////////////// 00461 BFEXPORT_FUNCDEC int BFSetFileOptionUsingChannel(const BFHANDLE request, const enum FileOptions option, BFCHANNEL * channel, BFHANDLE * errorinfo); 00462 00463 /////////////////////////////////////////////////////////////////////////////// 00464 /// <b>FOR INTERNAL USE ONLY</b> Sets a file option using a set of callbacks routines, making a copy of 00465 /// those routines. 00466 /// @param request BFHANDLE that represents the request 00467 /// @param option One of the values in FileOptions 00468 /// @param channel Pointer to a BFCHANNEL structure contained read, 00469 /// write and other IO routines supplied your code. 00470 /// @param copy Pointer that recieves a pointer to the copied BFCHANNEL. 00471 /// @param errorinfo Pointer to a handle that will be set to an error information 00472 /// handle if the function's return value is not BFRESULT_OK. 00473 /// This parameter may be NULL and may be set to NULL if no error information is available. 00474 /// @return One of the BFRESULT codes 00475 /////////////////////////////////////////////////////////////////////////////// 00476 BFEXPORT_FUNCDEC int BFSetFileOptionUsingChannelCopy(const BFHANDLE request, const enum FileOptions option, BFCHANNEL * channel, BFCHANNEL * * copy, BFHANDLE * errorinfo); 00477 00478 /////////////////////////////////////////////////////////////////////////////// 00479 /// <b>FOR INTERNAL USE ONLY</b> Frees a channel. 00480 /// @param channel Pointer to a BFCHANNEL structure to be freed. This pointer 00481 /// must have been the result of a 00482 /// BFSetFileOptionUsingChannelCopy() call 00483 /// @return One of the BFRESULT codes 00484 /////////////////////////////////////////////////////////////////////////////// 00485 BFEXPORT_FUNCDEC void BFFreeChannelCopy(BFCHANNEL * channel); 00486 00487 /////////////////////////////////////////////////////////////////////////////// 00488 /// Sets a file format option. 00489 /// @param request BFHANDLE that represents the request 00490 /// @param option One of the values in FileFormatOptions 00491 /// @param format One of the values in FileFormats 00492 /// @param errorinfo Pointer to a handle that will be set to an error information 00493 /// handle if the function's return value is not BFRESULT_OK. 00494 /// This parameter may be NULL and may be set to NULL if no error information is available. 00495 /// @return One of the BFRESULT codes 00496 /////////////////////////////////////////////////////////////////////////////// 00497 BFEXPORT_FUNCDEC int BFSetFileFormatOption(const BFHANDLE request, const enum FileFormatOptions option, const enum FileFormats format, BFHANDLE * errorinfo); 00498 00499 /////////////////////////////////////////////////////////////////////////////// 00500 /// Sets a file format list option. 00501 /// @param request BFHANDLE that represents the request 00502 /// @param option One of the values in FileFormatListOptions 00503 /// @param formats Any array containing zero or more FileFormats 00504 /// @param count Number of FileFormats in the formats array 00505 /// @param errorinfo Pointer to a handle that will be set to an error information 00506 /// handle if the function's return value is not BFRESULT_OK. 00507 /// This parameter may be NULL and may be set to NULL if no error information is available. 00508 /// @return One of the BFRESULT codes 00509 /////////////////////////////////////////////////////////////////////////////// 00510 BFEXPORT_FUNCDEC int BFSetFileFormatListOption(const BFHANDLE request, const enum FileFormatListOptions option, const enum FileFormats formats[], const int count, BFHANDLE * errorinfo); 00511 00512 /////////////////////////////////////////////////////////////////////////////// 00513 /// Sets an element handler option. 00514 /// @param request BFHANDLE that represents the request 00515 /// @param option Current only the value ExtractElementHandler is allowed 00516 /// @param handler A BFELEMENTHANDLER structure with all function pointers initialized to NULL or valid functions 00517 /// @param errorinfo Pointer to a handle that will be set to an error information 00518 /// handle if the function's return value is not BFRESULT_OK. 00519 /// This parameter may be NULL and may be set to NULL if no error information is available. 00520 /// @return One of the BFRESULT codes 00521 /////////////////////////////////////////////////////////////////////////////// 00522 BFEXPORT_FUNCDEC int BFSetHandlerOption(const BFHANDLE request, const enum HandlerOptions option, const BFELEMENTHANDLER * handler, BFHANDLE * errorinfo); 00523 00524 BFEXPORT_FUNCDEC int BFSetHandlerOptionCopy(const BFHANDLE request, const enum HandlerOptions option, const BFELEMENTHANDLER * handler, BFHANDLE * errorinfo); 00525 00526 /////////////////////////////////////////////////////////////////////////////// 00527 /// Gets a scrub option. 00528 /// @param request BFHANDLE that represents the request 00529 /// @param option One of the values in ScrubOptions 00530 /// @param action Pointer to an Actions that will receive the value 00531 /// @param errorinfo Pointer to a handle that will be set to an error information 00532 /// handle if the function's return value is not BFRESULT_OK. 00533 /// This parameter may be NULL and may be set to NULL if no error information is available. 00534 /// @return One of the BFRESULT codes 00535 /////////////////////////////////////////////////////////////////////////////// 00536 BFEXPORT_FUNCDEC int BFGetScrubOption(const BFHANDLE request, const enum ScrubOptions option, enum ScrubOptionActions * action, BFHANDLE * errorinfo); 00537 00538 /////////////////////////////////////////////////////////////////////////////// 00539 /// Gets an analyze option. 00540 /// @param request BFHANDLE that represents the request 00541 /// @param option One of the values in AnalyzeOptions 00542 /// @param action Pointer to an Actions that will receive the value 00543 /// @param errorinfo Pointer to a handle that will be set to an error information 00544 /// handle if the function's return value is not BFRESULT_OK. 00545 /// This parameter may be NULL and may be set to NULL if no error information is available. 00546 /// @return One of the BFRESULT codes 00547 /////////////////////////////////////////////////////////////////////////////// 00548 BFEXPORT_FUNCDEC int BFGetAnalyzeOption(const BFHANDLE request, const enum AnalyzeOptions option, enum ScrubOptionActions * action, BFHANDLE * errorinfo); 00549 00550 00551 /////////////////////////////////////////////////////////////////////////////// 00552 /// Gets a boolean option. 00553 /// @param request BFHANDLE that represents the request 00554 /// @param option One of the values in BooleanOptions 00555 /// @param value Pointer to an int that will receive either BFTRUE or BFFALSE 00556 /// @param errorinfo Pointer to a handle that will be set to an error information 00557 /// handle if the function's return value is not BFRESULT_OK. 00558 /// This parameter may be NULL and may be set to NULL if no error information is available. 00559 /// @return One of the BFRESULT codes. 00560 /////////////////////////////////////////////////////////////////////////////// 00561 BFEXPORT_FUNCDEC int BFGetBooleanOption(const BFHANDLE request, const enum BooleanOptions option, int * value, BFHANDLE * errorinfo); 00562 00563 /////////////////////////////////////////////////////////////////////////////// 00564 /// Gets an integer option. 00565 /// @param request BFHANDLE that represents the request 00566 /// @param option One of the values in IntegerOptions 00567 /// @param value Pointer to an int that will receive the value 00568 /// @param errorinfo Pointer to a handle that will be set to an error information 00569 /// handle if the function's return value is not BFRESULT_OK. 00570 /// This parameter may be NULL and may be set to NULL if no error information is available. 00571 /// @return One of the BFRESULT codes. 00572 /////////////////////////////////////////////////////////////////////////////// 00573 BFEXPORT_FUNCDEC int BFGetIntegerOption(const BFHANDLE request, const enum IntegerOptions option, BFINT64 * value, BFHANDLE * errorinfo); 00574 00575 /////////////////////////////////////////////////////////////////////////////// 00576 /// Gets a string option. 00577 /// @param request BFHANDLE that represents the request 00578 /// @param option One of the values in StringOptions 00579 /// @param string Pointer to a buffer of wide charcters that will receive the 00580 /// zero-terminated UNICODE string 00581 /// @param length Length of the buffer in characters. Returned string will be truncated if 00582 /// it will not fit in the buffer. 00583 /// @param errorinfo Pointer to a handle that will be set to an error information 00584 /// handle if the function's return value is not BFRESULT_OK. 00585 /// This parameter may be NULL and may be set to NULL if no error information is available. 00586 /// @return One of the BFRESULT codes 00587 /////////////////////////////////////////////////////////////////////////////// 00588 BFEXPORT_FUNCDEC int BFGetStringOption(const BFHANDLE request, const enum StringOptions option, wchar_t * string, int length, BFHANDLE * errorinfo); 00589 00590 /////////////////////////////////////////////////////////////////////////////// 00591 /// Gets a enum option. 00592 /// @param request BFHANDLE that represents the request 00593 /// @param option One of the values in EnumOptions 00594 /// @param value Pointer to an int that will receive the value 00595 /// @param errorinfo Pointer to a handle that will be set to an error information 00596 /// handle if the function's return value is not BFRESULT_OK. 00597 /// This parameter may be NULL and may be set to NULL if no error information is available. 00598 /// @return One of the BFRESULT codes 00599 /////////////////////////////////////////////////////////////////////////////// 00600 BFEXPORT_FUNCDEC int BFGetEnumOption(const BFHANDLE request, const enum EnumOptions option, int * value, BFHANDLE * errorinfo); 00601 00602 /////////////////////////////////////////////////////////////////////////////// 00603 /// Gets a string list option. 00604 /// @param request BFHANDLE that represents the request 00605 /// @param option One of the values in StringListOptions 00606 /// @param strings Array of pointers to Unicode string buffers that will receive the values. If this parameter is NULL then count will be set to the size of the array required to hold all the strings. 00607 /// @param count Pointer to an integer that specifies how large the passed strings array is and will receive the actual number of strings. 00608 /// @param length Length of the string buffers in characters. Each returned string will be truncated if 00609 /// it does not fit in the buffer. 00610 /// @param errorinfo Pointer to a handle that will be set to an error information 00611 /// handle if the function's return value is not BFRESULT_OK. 00612 /// This parameter may be NULL and may be set to NULL if no error information is available. 00613 /// @return One of the BFRESULT codes 00614 /////////////////////////////////////////////////////////////////////////////// 00615 BFEXPORT_FUNCDEC int BFGetStringListOption(const BFHANDLE request, const enum StringListOptions option, wchar_t * strings[], int * count, int length, BFHANDLE * errorinfo); 00616 00617 /////////////////////////////////////////////////////////////////////////////// 00618 /// Gets a list of file formats and associated descriptions that apply to a given target option (an analyze option or scrub option). 00619 /// @param option One of the values in AnalyzeOptions or ScrubOptions 00620 /// @param formats Array of FileFormats that will recieve the formats that apply to the target option. If this parameter or the descriptions parameter is NULL then count will be set to the size of the array required to hold all the descriptions. 00621 /// @param descriptions Array of pointers to Unicode string buffers that will receive the descirptions of how each formats applies to the target option. If this parameter or the formats parameter is NULL then count will be set to the size of the array required to hold all the descriptions. 00622 /// @param count Pointer to an integer that specifies how large the passed arrays (they must be the same) are and will receive the actual number of items. 00623 /// @param length Length of the string buffers in characters. Each returned string will be truncated if it does not fit in the buffer. 00624 /// @param errorinfo Pointer to a handle that will be set to an error information 00625 /// handle if the function's return value is not BFRESULT_OK. 00626 /// This parameter may be NULL and may be set to NULL if no error information is available. 00627 /// @return One of the BFRESULT codes 00628 /////////////////////////////////////////////////////////////////////////////// 00629 BFEXPORT_FUNCDEC int BFGetTargetOptionFormatInformation(const int option, enum FileFormats * formats, wchar_t * descriptions[], int * count, const int length, BFHANDLE * errorinfo); 00630 00631 /////////////////////////////////////////////////////////////////////////////// 00632 /// Gets a file option. 00633 /// @param request BFHANDLE that represents the request 00634 /// @param option One of the values in FileOptions 00635 /// @param path Pointer to a buffer of wide charcters that will receive the 00636 /// zero-terminated UNICODE string contained the full path to 00637 /// the file 00638 /// @param length Length of the buffer. Returned path will be truncated if 00639 /// it will not fit in the buffer. 00640 /// @param errorinfo Pointer to a handle that will be set to an error information 00641 /// handle if the function's return value is not BFRESULT_OK. 00642 /// This parameter may be NULL and may be set to NULL if no error information is available. 00643 /// @return One of the BFRESULT codes 00644 /////////////////////////////////////////////////////////////////////////////// 00645 BFEXPORT_FUNCDEC int BFGetFileOption(const BFHANDLE request, const enum FileOptions option, wchar_t * path, int length, BFHANDLE * errorinfo); 00646 00647 /////////////////////////////////////////////////////////////////////////////// 00648 /// Gets a directory option. 00649 /// @param request BFHANDLE that represents the request 00650 /// @param option One of the values in FileOptions 00651 /// @param path Pointer to a buffer of wide charcters that will receive the 00652 /// zero-terminated UNICODE string contained the full path to 00653 /// the directory 00654 /// @param length Length of the buffer. Returned path will be truncated if 00655 /// it will not fit in the buffer. 00656 /// @param errorinfo Pointer to a handle that will be set to an error information 00657 /// handle if the function's return value is not BFRESULT_OK. 00658 /// This parameter may be NULL and may be set to NULL if no error information is available. 00659 /// @return One of the BFRESULT codes 00660 /////////////////////////////////////////////////////////////////////////////// 00661 BFEXPORT_FUNCDEC int BFGetDirectoryOption(const BFHANDLE request, const enum DirectoryOptions option, wchar_t * path, int length, BFHANDLE * errorinfo); 00662 00663 /////////////////////////////////////////////////////////////////////////////// 00664 /// Gets a file format option. 00665 /// @param request BFHANDLE that represents the request 00666 /// @param option One of the values in FileFormatOptions 00667 /// @param format Pointer to a FileFormats that will receive the value 00668 /// @param errorinfo Pointer to a handle that will be set to an error information 00669 /// handle if the function's return value is not BFRESULT_OK. 00670 /// This parameter may be NULL and may be set to NULL if no error information is available. 00671 /// @return One of the BFRESULT codes 00672 /////////////////////////////////////////////////////////////////////////////// 00673 BFEXPORT_FUNCDEC int BFGetFileFormatOption(const BFHANDLE request, const enum FileFormatOptions option, enum FileFormats * format, BFHANDLE * errorinfo); 00674 00675 /////////////////////////////////////////////////////////////////////////////// 00676 /// Gets a file format list option. 00677 /// @param request BFHANDLE that represents the request 00678 /// @param option One of the values in FileFormatListOptions 00679 /// @param formats Pointer to an array of FileFormats that will receive the values. If this parameter is NULL then count will be set to the size of the array required to hold all the FileFormat values. 00680 /// @param count Pointer to an integer that specifies how large the passed formats array is and will receive the actual number of FileFormats values. 00681 /// @param errorinfo Pointer to a handle that will be set to an error information 00682 /// handle if the function's return value is not BFRESULT_OK. 00683 /// This parameter may be NULL and may be set to NULL if no error information is available. 00684 /// @return One of the BFRESULT codes 00685 /////////////////////////////////////////////////////////////////////////////// 00686 BFEXPORT_FUNCDEC int BFGetFileFormatListOption(const BFHANDLE request, const enum FileFormatListOptions option, enum FileFormats * formats, int * count, BFHANDLE * errorinfo); 00687 00688 /////////////////////////////////////////////////////////////////////////////// 00689 /// Read options from an XML file. 00690 /// @param request BFHANDLE that represents the request 00691 /// @param path Full path to the XML file to read 00692 /// @param errorinfo Pointer to a handle that will be set to an error information 00693 /// handle if the function's return value is not BFRESULT_OK. 00694 /// This parameter may be NULL and may be set to NULL if no error information is available. 00695 /// @return One of the BFRESULT codes 00696 /////////////////////////////////////////////////////////////////////////////// 00697 BFEXPORT_FUNCDEC int BFReadOptionsFromXML(const BFHANDLE request, const wchar_t * path, BFHANDLE * errorinfo); 00698 00699 /////////////////////////////////////////////////////////////////////////////// 00700 /// Write options from an XML file. 00701 /// @param request BFHANDLE that represents the request 00702 /// @param path Full path to the XML file to write 00703 /// @param errorinfo Pointer to a handle that will be set to an error information 00704 /// handle if the function's return value is not BFRESULT_OK. 00705 /// This parameter may be NULL and may be set to NULL if no error information is available. 00706 /// @return One of the BFRESULT codes 00707 /////////////////////////////////////////////////////////////////////////////// 00708 BFEXPORT_FUNCDEC int BFWriteOptionsToXML(const BFHANDLE request, const wchar_t * path, BFHANDLE * errorinfo); 00709 00710 /// 00711 /// @} 00712 /// 00713 00714 /// 00715 /// @defgroup response Response processing 00716 /// Functions to deal with the response provided by BFGetSecureResponse() 00717 /// @{ 00718 /// 00719 00720 /////////////////////////////////////////////////////////////////////////////// 00721 /// Destory a secure response. The response should never again be used after 00722 /// this function returns. 00723 /// @param response BFHANDLE response to be closed 00724 /// @param errorinfo Pointer to a handle that will be set to an error information 00725 /// handle if the function's return value is not BFRESULT_OK. 00726 /// This parameter may be NULL and may be set to NULL if no error information is available. 00727 /// @return One of the BFRESULT codes 00728 /////////////////////////////////////////////////////////////////////////////// 00729 BFEXPORT_FUNCDEC int BFCloseSecureResponse(const BFHANDLE response, BFHANDLE * errorinfo); 00730 00731 /////////////////////////////////////////////////////////////////////////////// 00732 /// Gets a scrub result from a response. 00733 /// @param response BFHANDLE that represents the response 00734 /// @param option One of the values in ScrubOptions 00735 /// @param result Pointer to an Reactions that will receive the value 00736 /// @param errorinfo Pointer to a handle that will be set to an error information 00737 /// handle if the function's return value is not BFRESULT_OK. 00738 /// This parameter may be NULL and may be set to NULL if no error information is available. 00739 /// @return One of the BFRESULT codes 00740 /////////////////////////////////////////////////////////////////////////////// 00741 BFEXPORT_FUNCDEC int BFGetScrubResult(const BFHANDLE response, const enum ScrubOptions option, enum ScrubOptionReactions * result, BFHANDLE * errorinfo); 00742 00743 /////////////////////////////////////////////////////////////////////////////// 00744 /// Gets an analyze result from a response. 00745 /// @param response BFHANDLE that represents the response 00746 /// @param option One of the values in AnalyzeOptions 00747 /// @param reaction Pointer to an Reactions that will receive the value. Note 00748 /// since this is an analyze result the reaction will never be 00749 /// ScrubbedReaction. 00750 /// @param errorinfo Pointer to a handle that will be set to an error information 00751 /// handle if the function's return value is not BFRESULT_OK. 00752 /// This parameter may be NULL and may be set to NULL if no error information is available. 00753 /// @return One of the BFRESULT codes 00754 /////////////////////////////////////////////////////////////////////////////// 00755 BFEXPORT_FUNCDEC int BFGetAnalyzeResult(const BFHANDLE response, const enum AnalyzeOptions option, enum ScrubOptionReactions * reaction, BFHANDLE * errorinfo); 00756 00757 /////////////////////////////////////////////////////////////////////////////// 00758 /// Gets a boolean result from a response. 00759 /// @param response BFHANDLE that represents the response 00760 /// @param option One of the values in BooleanOptions 00761 /// @param result Pointer to an int that will receive either BFTRUE or BFFALSE 00762 /// @param errorinfo Pointer to a handle that will be set to an error information 00763 /// handle if the function's return value is not BFRESULT_OK. 00764 /// This parameter may be NULL and may be set to NULL if no error information is available. 00765 /// @return One of the BFRESULT codes 00766 /////////////////////////////////////////////////////////////////////////////// 00767 BFEXPORT_FUNCDEC int BFGetBooleanResult(const BFHANDLE response, const enum BooleanOptions option, int * result, BFHANDLE * errorinfo); 00768 00769 /////////////////////////////////////////////////////////////////////////////// 00770 /// Gets an enumeration result from a response. 00771 /// @param response BFHANDLE that represents the response 00772 /// @param option One of the values in EnumOptions 00773 /// @param result Pointer to an int that will receive the value 00774 /// @param errorinfo Pointer to a handle that will be set to an error information 00775 /// handle if the function's return value is not BFRESULT_OK. 00776 /// This parameter may be NULL and may be set to NULL if no error information is available. 00777 /// @return One of the BFRESULT codes 00778 /////////////////////////////////////////////////////////////////////////////// 00779 BFEXPORT_FUNCDEC int BFGetEnumResult(const BFHANDLE response, const enum EnumOptions option, int * result, BFHANDLE * errorinfo); 00780 00781 /////////////////////////////////////////////////////////////////////////////// 00782 /// Gets a file format result from a response. 00783 /// @param response BFHANDLE that represents the response 00784 /// @param option One of the values in FileFormatOptions 00785 /// @param format Pointer to an FileFormats that will receive the value. 00786 /// @param errorinfo Pointer to a handle that will be set to an error information 00787 /// handle if the function's return value is not BFRESULT_OK. 00788 /// This parameter may be NULL and may be set to NULL if no error information is available. 00789 /// @return One of the BFRESULT codes 00790 /////////////////////////////////////////////////////////////////////////////// 00791 BFEXPORT_FUNCDEC int BFGetFileFormatResult(const BFHANDLE response, const enum FileFormatOptions option, enum FileFormats * format, BFHANDLE * errorinfo); 00792 00793 /////////////////////////////////////////////////////////////////////////////// 00794 /// Compare two responses. This function is exposed primarily for testing 00795 /// purposes. 00796 /// @param response1 BFHANDLE that represents a response 00797 /// @param response2 BFHANDLE that represents a response 00798 /// @param errorinfo Pointer to a handle that will be set to an error information 00799 /// handle if the function's return value is not BFRESULT_OK. 00800 /// This parameter may be NULL and may be set to NULL if no error information is available. 00801 /// @return BFTRUE if the responses contain all the same values, BFFALSE otherwise 00802 /////////////////////////////////////////////////////////////////////////////// 00803 BFEXPORT_FUNCDEC int BFCompareResponse(const BFHANDLE response1, const BFHANDLE response2, BFHANDLE * errorinfo); 00804 00805 /// 00806 /// @} 00807 /// 00808 00809 00810 /// 00811 /// @defgroup optioninfo Option information 00812 /// Functions that provide information about a particular option 00813 /// @{ 00814 /// 00815 00816 /////////////////////////////////////////////////////////////////////////////// 00817 /// Gets the identifier for an option. The id will be less than 80 00818 /// characters long. 00819 /// @param option One of the values in ScrubOptions, AnalyzeOptions, 00820 /// BooleanOptions, FileFormatOptions or FileOptions 00821 /// @param name Pointer to a buffer of wide charcters that will receive the 00822 /// zero-terminated UNICODE id 00823 /// @param length Length of the buffer in characters. Returned string will be 00824 /// truncated if it will not fit in the buffer. 00825 /// @param errorinfo Pointer to a handle that will be set to an error information 00826 /// handle if the function's return value is not BFRESULT_OK. 00827 /// This parameter may be NULL and may be set to NULL if no error information is available. 00828 /// @return One of the BFRESULT codes 00829 /////////////////////////////////////////////////////////////////////////////// 00830 BFEXPORT_FUNCDEC int BFGetOptionId(int option, wchar_t * name, int length, BFHANDLE * errorinfo); 00831 00832 /////////////////////////////////////////////////////////////////////////////// 00833 /// Gets the short name for an option. The name will be less than 80 00834 /// characters long. 00835 /// @param option One of the values in ScrubOptions, AnalyzeOptions, 00836 /// BooleanOptions, FileFormatOptions or FileOptions 00837 /// @param name Pointer to a buffer of wide charcters that will receive the 00838 /// zero-terminated UNICODE short name 00839 /// @param length Length of the buffer in characters. Returned string will be 00840 /// truncated if it will not fit in the buffer. 00841 /// @param errorinfo Pointer to a handle that will be set to an error information 00842 /// handle if the function's return value is not BFRESULT_OK. 00843 /// This parameter may be NULL and may be set to NULL if no error information is available. 00844 /// @return One of the BFRESULT codes 00845 /////////////////////////////////////////////////////////////////////////////// 00846 BFEXPORT_FUNCDEC int BFGetOptionName(int option, wchar_t * name, int length, BFHANDLE * errorinfo); 00847 00848 /////////////////////////////////////////////////////////////////////////////// 00849 /// Gets the short description for an option. The description will be less 00850 /// than 1024 characters long. 00851 /// @param option One of the values in ScrubOptions, AnalyzeOptions, 00852 /// BooleanOptions, FileFormatOptions or FileOptions 00853 /// @param description Pointer to a buffer of wide charcters that will receive the 00854 /// zero-terminated UNICODE short description 00855 /// @param length Length of the buffer in characters. Returned string will be 00856 /// truncated if it will not fit in the buffer. 00857 /// @param errorinfo Pointer to a handle that will be set to an error information 00858 /// handle if the function's return value is not BFRESULT_OK. 00859 /// This parameter may be NULL and may be set to NULL if no error information is available. 00860 /// @return One of the BFRESULT codes 00861 /////////////////////////////////////////////////////////////////////////////// 00862 BFEXPORT_FUNCDEC int BFGetOptionShortDescription(int option, wchar_t * description, int length, BFHANDLE * errorinfo); 00863 00864 /////////////////////////////////////////////////////////////////////////////// 00865 /// Gets the long description for an option. The description will be less 00866 /// than 10240 characters long. 00867 /// @param option One of the values in ScrubOptions, AnalyzeOptions, 00868 /// BooleanOptions, FileFormatOptions or FileOptions 00869 /// @param description Pointer to a buffer of wide charcters that will receive the 00870 /// zero-terminated UNICODE long description 00871 /// @param length Length of the buffer in characters. Returned string will be 00872 /// truncated if it will not fit in the buffer. 00873 /// @param errorinfo Pointer to a handle that will be set to an error information 00874 /// handle if the function's return value is not BFRESULT_OK. 00875 /// This parameter may be NULL and may be set to NULL if no error information is available. 00876 /// @return One of the BFRESULT codes 00877 /////////////////////////////////////////////////////////////////////////////// 00878 BFEXPORT_FUNCDEC int BFGetOptionLongDescription(int option, wchar_t * description, int length, BFHANDLE * errorinfo); 00879 00880 /// 00881 /// @} 00882 /// 00883 00884 /// 00885 /// @defgroup fileformat File format information 00886 /// Functions that provide information about a particular file format 00887 /// @{ 00888 /// 00889 00890 /////////////////////////////////////////////////////////////////////////////// 00891 /// Gets the name of a file format. The name will be less than 80 00892 /// characters long. 00893 /// @param format One of the values in FileFormats 00894 /// @param name Pointer to a buffer of wide characters that will receive the 00895 /// zero-terminated UNICODE name 00896 /// @param length Length of the buffer in characters. Returned string will be 00897 /// truncated if it will not fit in the buffer. 00898 /// @param errorinfo Pointer to a handle that will be set to an error information 00899 /// handle if the function's return value is not BFRESULT_OK. 00900 /// This parameter may be NULL and may be set to NULL if no error information is available. 00901 /// @return One of the BFRESULT codes 00902 /////////////////////////////////////////////////////////////////////////////// 00903 BFEXPORT_FUNCDEC int BFGetFileFormatName(const enum FileFormats format, wchar_t * name, int length, BFHANDLE * errorinfo); 00904 00905 /////////////////////////////////////////////////////////////////////////////// 00906 /// Gets the id of a file format. The id will be less than 80 00907 /// characters long. 00908 /// @param format One of the values in FileFormats 00909 /// @param id Pointer to a buffer of wide characters that will receive the 00910 /// zero-terminated UNICODE id 00911 /// @param length Length of the buffer in characters. Returned string will be 00912 /// truncated if it will not fit in the buffer. 00913 /// @param errorinfo Pointer to a handle that will be set to an error information 00914 /// handle if the function's return value is not BFRESULT_OK. 00915 /// This parameter may be NULL and may be set to NULL if no error information is available. 00916 /// @return One of the BFRESULT codes 00917 /////////////////////////////////////////////////////////////////////////////// 00918 BFEXPORT_FUNCDEC int BFGetFileFormatId(const enum FileFormats format, wchar_t * id, int length, BFHANDLE * errorinfo); 00919 00920 /////////////////////////////////////////////////////////////////////////////// 00921 /// Gets the description of a file format. The description will be less than 00922 /// 1024 characters long. 00923 /// @param format One of the values in FileFormats 00924 /// @param description Pointer to a buffer of wide charcters that will receive the 00925 /// zero-terminated UNICODE description 00926 /// @param length Length of the buffer in characters. Returned string will be 00927 /// truncated if it will not fit in the buffer. 00928 /// @param errorinfo Pointer to a handle that will be set to an error information 00929 /// handle if the function's return value is not BFRESULT_OK. 00930 /// This parameter may be NULL and may be set to NULL if no error information is available. 00931 /// @return One of the BFRESULT codes 00932 /////////////////////////////////////////////////////////////////////////////// 00933 BFEXPORT_FUNCDEC int BFGetFileFormatDescription(const enum FileFormats format, wchar_t * description, int length, BFHANDLE * errorinfo); 00934 00935 /////////////////////////////////////////////////////////////////////////////// 00936 /// Gets the extension associted with a file format. The extension will be less than 00937 /// 1024 characters long and likely 3 or 4. 00938 /// @param format One of the values in FileFormats 00939 /// @param extension Pointer to a buffer of wide charcters that will receive the 00940 /// zero-terminated UNICODE extension 00941 /// @param length Length of the buffer in characters. Returned string will be 00942 /// truncated if it will not fit in the buffer. 00943 /// @param errorinfo Pointer to a handle that will be set to an error information 00944 /// handle if the function's return value is not BFRESULT_OK. 00945 /// This parameter may be NULL and may be set to NULL if no error information is available. 00946 /// @return One of the BFRESULT codes 00947 /////////////////////////////////////////////////////////////////////////////// 00948 BFEXPORT_FUNCDEC int BFGetFileFormatExtension(const enum FileFormats format, wchar_t * extension, int length, BFHANDLE * errorinfo); 00949 00950 /// 00951 /// @} 00952 /// 00953 00954 00955 /// 00956 /// @defgroup handler Extraction handler 00957 /// Functions and strcutures that provide the developer direct access to 00958 /// to the data extracted from a document. 00959 /// @{ 00960 /// 00961 00962 00963 /// 00964 /// @} 00965 /// 00966 00967 00968 00969 /// 00970 /// @defgroup error Result codes and error processing 00971 /// Result codes and functions to deal with error information 00972 /// @{ 00973 /// 00974 00975 00976 /////////////////////////////////////////////////////////////////////////////// 00977 /// Gets the single line error message. The message will a single line. 00978 /// @param errorinfo Handle returned by when another function failed 00979 /// @return message Pointer to a zero-terminated UNICODE message 00980 /////////////////////////////////////////////////////////////////////////////// 00981 BFEXPORT_FUNCDEC wchar_t const * BFGetErrorMessage(const BFHANDLE errorinfo); 00982 00983 /////////////////////////////////////////////////////////////////////////////// 00984 /// Gets the extended error message. This message may contain multiple lines. 00985 /// For Java-based exceptions this message will include the stack trace. 00986 /// @param errorinfo Handle returned by when another function failed 00987 /// @return Pointer to a zero-terminated UNICODE message 00988 /////////////////////////////////////////////////////////////////////////////// 00989 BFEXPORT_FUNCDEC wchar_t const * BFGetExtendedErrorMessage(const BFHANDLE errorinfo); 00990 00991 /////////////////////////////////////////////////////////////////////////////// 00992 /// Gets the extended error message. This message may contain multiple lines. 00993 /// For Java-based exceptions this message will include the stack trace. 00994 /// @param errorinfo Handle returned by when another function failed 00995 /// @return Handle to the error which caused this one or NULL if no cause exists. 00996 /// This handle may be used with BFGetErrorMessage, BFGetExtendedErrorMessage 00997 /// and BFGetErrorCause allowing to developer to get and report the entire 00998 /// chain of causes. Unlike the error handles return my other functions this handle 00999 /// does NOT need to be closed using BFCloseErrorInfo although doing so will 01000 /// not cause as problem. 01001 /////////////////////////////////////////////////////////////////////////////// 01002 BFEXPORT_FUNCDEC BFHANDLE BFGetErrorCause(const BFHANDLE errorinfo); 01003 01004 /////////////////////////////////////////////////////////////////////////////// 01005 /// Closes an error information handle. 01006 /// @param errorinfo Handle returned by when another function failed. To 01007 /// simplify using this API passing NULL to this function 01008 /// is valid and no action will be taken. 01009 /////////////////////////////////////////////////////////////////////////////// 01010 BFEXPORT_FUNCDEC void BFCloseErrorInfo(const BFHANDLE errorinfo); 01011 01012 /// 01013 /// @} 01014 /// 01015 01016 /// 01017 /// @defgroup helper Helper 01018 /// Functions that assist in using and testing this API 01019 /// @{ 01020 /// 01021 01022 /////////////////////////////////////////////////////////////////////////////// 01023 /// Date into string. 01024 /// This function is provided primarily for testing purposes. 01025 /////////////////////////////////////////////////////////////////////////////// 01026 BFEXPORT_FUNCDEC int BFHelperGetDateString(BFINT64 ms, wchar_t *string, int length, BFHANDLE * errorinfo); 01027 01028 /////////////////////////////////////////////////////////////////////////////// 01029 /// Duration into string. 01030 /// This function is provided primarily for testing purposes. 01031 /////////////////////////////////////////////////////////////////////////////// 01032 BFEXPORT_FUNCDEC void BFHelperGetDurationString(BFINT64 ms, wchar_t *string, int length); 01033 01034 /////////////////////////////////////////////////////////////////////////////// 01035 /// Double into string. 01036 /// This function is provided primarily for testing purposes. 01037 /////////////////////////////////////////////////////////////////////////////// 01038 BFEXPORT_FUNCDEC void BFHelperGetDoubleString(double d, wchar_t *string, int length); 01039 01040 /// 01041 /// @} 01042 /// 01043 01044 #ifdef __cplusplus 01045 } 01046 #endif 01047 01048 // Define C++ cover on C functions 01049 // This is only done for C++ and only when an OEM's code is 01050 // including this file. If we are build the library 01051 // then we don't want the C++ definitions to be included 01052 // and built into the library. This avoids any issues 01053 // with different compiler producing different C++ decoration. 01054 01055 #ifdef __cplusplus 01056 01057 #include <exception> 01058 #include <stdexcept> 01059 #include <string> 01060 01061 /////////////////////////////////////////////////////////////////////////////// 01062 /// Clean Content Exception class 01063 /////////////////////////////////////////////////////////////////////////////// 01064 01065 class BFTransformException : public std::exception { 01066 private: 01067 std::wstring message; 01068 std::wstring extended; 01069 BFTransformException * cause; 01070 char mbmessage[1024]; 01071 public: 01072 BFTransformException(BFHANDLE errorinfo); 01073 BFTransformException(std::wstring const &msg, std::wstring const &ext); 01074 BFTransformException(const wchar_t * msg, const wchar_t * ext); 01075 BFTransformException(); 01076 BFTransformException(const BFTransformException& source); 01077 BFTransformException& operator = (const BFTransformException& source); 01078 ~BFTransformException() throw(); 01079 virtual char const *what() const throw(); 01080 std::wstring const &wwhat(); 01081 std::wstring const &wextended(); 01082 BFTransformException *getCause(); 01083 }; 01084 01085 /////////////////////////////////////////////////////////////////////////////// 01086 /// An abstract base class the the developer must derive from in order 01087 /// to provide a parameter to the 01088 /// BFSecureRequest::SetOption(FileOptions option,BFChannel * channel) 01089 /// method. The developer is free to implement Read, Write, 01090 /// etc. however they see fit. The prototypical example of using a BFChannel 01091 /// is the processing of documents that reside in a database or some other 01092 /// location not accessable through the file system. 01093 /////////////////////////////////////////////////////////////////////////////// 01094 01095 class BFChannel 01096 { 01097 public: 01098 /////////////////////////////////////////////////////////////////////////////// 01099 /// Member function that reads bytes from the channel. 01100 /// @param buffer The buffer to read bytes into 01101 /// @param count Number of bytes to read 01102 /// @param position Offset in the file the bytes should be read at 01103 /// @return The number of bytes actually read. A number less than count or 0 01104 /// means the end of file has been reached. 01105 /////////////////////////////////////////////////////////////////////////////// 01106 virtual long Read(void * buffer, BFINT32 count, BFINT64 position) = 0; 01107 /////////////////////////////////////////////////////////////////////////////// 01108 /// Member function that writes bytes to the channel. 01109 /// @param buffer The buffer containing the bytes to write 01110 /// @param count Number of bytes to write 01111 /// @param position Offset in the file the bytes should be written to 01112 /////////////////////////////////////////////////////////////////////////////// 01113 virtual void Write(void * buffer, BFINT32 count, BFINT64 position) = 0; 01114 /////////////////////////////////////////////////////////////////////////////// 01115 /// Member function that provides the size of the channel. 01116 /// @return The number of bytes in the file. 01117 /////////////////////////////////////////////////////////////////////////////// 01118 virtual BFINT64 Size() = 0; 01119 /////////////////////////////////////////////////////////////////////////////// 01120 /// Member function that returns information about what features this 01121 /// channel supports. 01122 /// @return BFCHANNELCANREAD, BFCHANNELCANWRITE or both ORed together 01123 /////////////////////////////////////////////////////////////////////////////// 01124 virtual long Supports() = 0; 01125 /////////////////////////////////////////////////////////////////////////////// 01126 /// Member function that closes the channel. The developer is gaurenteed 01127 /// that no other calls will be made to the channel after this call is made. 01128 /////////////////////////////////////////////////////////////////////////////// 01129 virtual void Close() = 0; 01130 /////////////////////////////////////////////////////////////////////////////// 01131 /// Member function that truncates the channel. 01132 /////////////////////////////////////////////////////////////////////////////// 01133 virtual void Truncate(BFINT64 size) = 0; 01134 }; 01135 01136 01137 #ifdef BFDEFINECPP 01138 01139 /// BFTransformException 01140 /// BFTransformException 01141 /// BFTransformException 01142 /// BFTransformException 01143 /// BFTransformException 01144 01145 inline BFTransformException::BFTransformException(BFHANDLE errorinfo) 01146 : message(BFGetErrorMessage(errorinfo)), 01147 extended(BFGetExtendedErrorMessage(errorinfo)) 01148 { 01149 BFHANDLE c = BFGetErrorCause(errorinfo); 01150 if (c != NULL) 01151 cause = new BFTransformException(c); 01152 else 01153 cause = NULL; 01154 BFCloseErrorInfo(errorinfo); 01155 wcstombs(mbmessage,message.c_str(),1024); 01156 } 01157 01158 inline BFTransformException::BFTransformException(std::wstring const &msg, std::wstring const &ext) 01159 : message(msg), 01160 extended(ext) 01161 { 01162 cause = NULL; 01163 wcstombs(mbmessage,message.c_str(),1024); 01164 } 01165 01166 inline BFTransformException::BFTransformException(const wchar_t * msg, const wchar_t * ext) 01167 : message(msg), 01168 extended(ext) 01169 { 01170 cause = NULL; 01171 wcstombs(mbmessage,message.c_str(),1024); 01172 } 01173 01174 inline BFTransformException::BFTransformException() 01175 : message(L"Unknown"), 01176 extended(L"Unknown") 01177 { 01178 cause = NULL; 01179 strcpy(mbmessage,"Unknown"); 01180 } 01181 01182 inline BFTransformException::BFTransformException(const BFTransformException& source) 01183 : message(source.message), 01184 extended(source.extended) 01185 { 01186 if (source.cause != NULL) { 01187 cause = new BFTransformException(*(source.cause)); 01188 } else { 01189 cause = NULL; 01190 } 01191 wcstombs(mbmessage,message.c_str(),1024); 01192 } 01193 01194 inline BFTransformException& BFTransformException::operator = (const BFTransformException& source) 01195 { 01196 message = source.message; 01197 extended = source.extended; 01198 if (source.cause != NULL) { 01199 cause = new BFTransformException(*(source.cause)); 01200 } else { 01201 cause = NULL; 01202 } 01203 wcstombs(mbmessage,message.c_str(),1024); 01204 return *this; 01205 } 01206 01207 01208 inline BFTransformException::~BFTransformException() throw() { 01209 //printf("\r\nBFTransformException destructor %s\r\n",mbmessage); 01210 if (cause != NULL) delete cause; 01211 } 01212 inline char const * BFTransformException::what() const throw() {return mbmessage;} 01213 inline std::wstring const & BFTransformException::wwhat() {return message;} 01214 inline std::wstring const & BFTransformException::wextended() {return extended;} 01215 inline BFTransformException * BFTransformException::getCause() {return cause;} 01216 01217 // BFChannel 01218 // BFChannel 01219 // BFChannel 01220 // BFChannel 01221 // BFChannel 01222 01223 struct BFCPPCHANNEL { 01224 BFCHANNEL channel; 01225 BFChannel * channelObj; 01226 }; 01227 01228 inline void BFCppChannelClose(void * channel) { 01229 BFCPPCHANNEL * cppChannel = (BFCPPCHANNEL *)channel; 01230 cppChannel->channelObj->Close(); 01231 delete cppChannel; 01232 } 01233 01234 inline BFINT64 BFCppChannelSize(void * channel) { 01235 BFCPPCHANNEL * cppChannel = (BFCPPCHANNEL *)channel; 01236 return cppChannel->channelObj->Size(); 01237 } 01238 01239 inline long BFCppChannelSupports(void * channel) { 01240 BFCPPCHANNEL * cppChannel = (BFCPPCHANNEL *)channel; 01241 return cppChannel->channelObj->Supports(); 01242 } 01243 01244 inline void BFCppChannelWrite(void * channel, void * buf, BFINT32 len, BFINT64 pos) { 01245 BFCPPCHANNEL * cppChannel = (BFCPPCHANNEL *)channel; 01246 cppChannel->channelObj->Write(buf,len,pos); 01247 } 01248 01249 inline long BFCppChannelRead(void * channel, void * buf, BFINT32 len, BFINT64 pos) { 01250 BFCPPCHANNEL * cppChannel = (BFCPPCHANNEL *)channel; 01251 return cppChannel->channelObj->Read(buf,len,pos); 01252 } 01253 01254 inline void BFCppChannelTruncate(void * channel, BFINT64 size) { 01255 BFCPPCHANNEL * cppChannel = (BFCPPCHANNEL *)channel; 01256 cppChannel->channelObj->Truncate(size); 01257 } 01258 01259 inline void InitChannelForCpp(BFCHANNEL * channel) { 01260 channel->close = BFCppChannelClose; 01261 channel->read = BFCppChannelRead; 01262 channel->write = BFCppChannelWrite; 01263 channel->size = BFCppChannelSize; 01264 channel->supports = BFCppChannelSupports; 01265 channel->truncate = BFCppChannelTruncate; 01266 } 01267 01268 #endif // BFDEFINECPP 01269 01270 #include "secureapienumscpp.generated.h" 01271 01272 /////////////////////////////////////////////////////////////////////////////// 01273 /// An object that represents the response to execution of a 01274 /// BFSecureRequest::Execute. The constructor for 01275 /// this class is private because instances should only be retrieved 01276 /// through BFSecureRequest::GetSecureResponse. 01277 /////////////////////////////////////////////////////////////////////////////// 01278 class BFSecureResponse 01279 { 01280 private: 01281 BFHANDLE response; 01282 static void HandleError(int error, BFHANDLE errorinfo); 01283 BFSecureResponse(BFHANDLE res); 01284 friend class BFSecureRequest; 01285 public: 01286 /////////////////////////////////////////////////////////////////////////////// 01287 /// Destroys a BFSecureResponse object. 01288 /////////////////////////////////////////////////////////////////////////////// 01289 ~BFSecureResponse(); 01290 /////////////////////////////////////////////////////////////////////////////// 01291 /// Gets a boolean result from a response. 01292 /// @param option One of the values in BooleanOptions 01293 /// @return true or false 01294 /////////////////////////////////////////////////////////////////////////////// 01295 bool GetBooleanResult(BooleanOptions option); 01296 /////////////////////////////////////////////////////////////////////////////// 01297 /// Gets a enum result from a response. 01298 /// @param option One of the values in EnumOptions 01299 /// @return integer value 01300 /////////////////////////////////////////////////////////////////////////////// 01301 int GetEnumResult(EnumOptions option); 01302 /////////////////////////////////////////////////////////////////////////////// 01303 /// Gets a scrub result 01304 /// @param option One of the values in ScrubOptions 01305 /// @return One of the values in Reactions 01306 /////////////////////////////////////////////////////////////////////////////// 01307 ScrubOptionReactions GetScrubResult(ScrubOptions option); 01308 /////////////////////////////////////////////////////////////////////////////// 01309 /// Gets a analyze result 01310 /// @param option One of the values in AnalyzeOptions 01311 /// @return One of the values in Reactions 01312 /////////////////////////////////////////////////////////////////////////////// 01313 ScrubOptionReactions GetAnalyzeResult(AnalyzeOptions option); 01314 /////////////////////////////////////////////////////////////////////////////// 01315 /// Gets a file format result 01316 /// @param option One of the values in FileFormatOptions 01317 /// @return One of the values in FileFormats 01318 /////////////////////////////////////////////////////////////////////////////// 01319 FileFormats GetFileFormatResult(FileFormatOptions option); 01320 }; 01321 01322 /////////////////////////////////////////////////////////////////////////////// 01323 /// An object that represents a set of options 01324 /////////////////////////////////////////////////////////////////////////////// 01325 01326 class BFElementHandler; 01327 01328 class BFOptionSet 01329 { 01330 protected: 01331 BFHANDLE request; 01332 static void HandleError(int error, BFHANDLE errorinfo); 01333 BFOptionSet(); 01334 public: 01335 /////////////////////////////////////////////////////////////////////////////// 01336 /// Constructs a BFOptionSet object based on a C handle to an option set 01337 /////////////////////////////////////////////////////////////////////////////// 01338 BFOptionSet(const BFHANDLE optionset); 01339 /////////////////////////////////////////////////////////////////////////////// 01340 /// Destroys a BFOptionSet object 01341 /////////////////////////////////////////////////////////////////////////////// 01342 virtual ~BFOptionSet(); 01343 /////////////////////////////////////////////////////////////////////////////// 01344 /// Tests if an option set is valid 01345 /// @return TRUE if the option set is valid 01346 /////////////////////////////////////////////////////////////////////////////// 01347 bool IsValid(); 01348 /////////////////////////////////////////////////////////////////////////////// 01349 /// Sets a boolean option 01350 /// @param option One of the values in BooleanOptions 01351 /// @param value The option's new value 01352 /////////////////////////////////////////////////////////////////////////////// 01353 void SetOption(BooleanOptions option, const bool value); 01354 /////////////////////////////////////////////////////////////////////////////// 01355 /// Sets an integer option 01356 /// @param option One of the values in IntegerOptions 01357 /// @param value The option's new value 01358 /////////////////////////////////////////////////////////////////////////////// 01359 void SetOption(IntegerOptions option, const int value); 01360 /////////////////////////////////////////////////////////////////////////////// 01361 /// Sets a date option 01362 /// @param option One of the values in DateOptions 01363 /// @param year The year, value is AD 01364 /// @param month The month, value is 0-based where 0 is January 01365 /// @param day Day of the month 01366 /// @param hour Hour 01367 /// @param minute Minute 01368 /// @param second Second 01369 /////////////////////////////////////////////////////////////////////////////// 01370 void SetOption(DateOptions option, const int year, const int month, const int day, const int hour, const int minute, const int second); 01371 /////////////////////////////////////////////////////////////////////////////// 01372 /// Sets a duration option 01373 /// @param option One of the values in DurationOptions 01374 /// @param value The duration in milliseconds 01375 /////////////////////////////////////////////////////////////////////////////// 01376 void SetOption(DurationOptions option, const int value); 01377 /////////////////////////////////////////////////////////////////////////////// 01378 /// Sets an enum option 01379 /// @param option One of the values in EnumOptions 01380 /// @param value The option's new value 01381 /////////////////////////////////////////////////////////////////////////////// 01382 void SetOption(EnumOptions option, const int value); 01383 /////////////////////////////////////////////////////////////////////////////// 01384 /// Sets an enum list option 01385 /// @param option One of the values in EnumListOptions 01386 /// @param values The option's new values 01387 /// @param count The number of items in the values array 01388 /////////////////////////////////////////////////////////////////////////////// 01389 void SetOption(EnumListOptions option, const int values[], const int count); 01390 /////////////////////////////////////////////////////////////////////////////// 01391 /// Sets a string option 01392 /// @param option One of the values in StringOptions 01393 /// @param str The option's new value 01394 /////////////////////////////////////////////////////////////////////////////// 01395 void SetOption(StringOptions option, const std::wstring & str); 01396 /////////////////////////////////////////////////////////////////////////////// 01397 /// Sets a string list option 01398 /// @param option One of the values in StringListOptions 01399 /// @param strs An array of strings that will be the options new value 01400 /// @param count Number of stings in the array 01401 /////////////////////////////////////////////////////////////////////////////// 01402 void SetOption(StringListOptions option, const std::wstring strs[], const int count); 01403 /////////////////////////////////////////////////////////////////////////////// 01404 /// Sets a file option using a full path to a file 01405 /// @param option One of the values in FileOptions 01406 /// @param path A full path to the file 01407 /////////////////////////////////////////////////////////////////////////////// 01408 void SetOption(FileOptions option, const std::wstring & path); 01409 /////////////////////////////////////////////////////////////////////////////// 01410 /// Sets a file option using a memory buffer 01411 /// @param option One of the values in FileOptions 01412 /// @param memory Pointer to memory containing the entire file 01413 /// @param length Number of bytes in the file 01414 /////////////////////////////////////////////////////////////////////////////// 01415 void SetOption(FileOptions option, void * memory, const long length); 01416 /////////////////////////////////////////////////////////////////////////////// 01417 /// Sets a file option using a developer defined class derived from BFChannel 01418 /// @param option One of the values in FileOptions 01419 /// @param channel Pointer to an object derived from the BFChannel abstract 01420 /// base class. The developer continues to "own" this object 01421 /// and must gaurentee that this object is not 01422 /// deleted until after its Close member function is called. 01423 /////////////////////////////////////////////////////////////////////////////// 01424 void SetOption(FileOptions option, BFChannel * channel); 01425 /////////////////////////////////////////////////////////////////////////////// 01426 /// Sets a element handler option using a developer defined class derived 01427 /// from BFElementHandler 01428 /// @param option One of the values in HandlerOptions 01429 /// @param eh Pointer to an object derived from the BFChannel abstract 01430 /// base class. The developer continues to "own" this object 01431 /// and must gaurentee that this object is not 01432 /// deleted until after its Close member function is called. 01433 /////////////////////////////////////////////////////////////////////////////// 01434 void SetOption(HandlerOptions option, BFElementHandler * eh); 01435 /////////////////////////////////////////////////////////////////////////////// 01436 /// Sets a directory option using a full path to the directory 01437 /// @param option One of the values in DirectoryOptions 01438 /// @param path A full path to the directory 01439 /////////////////////////////////////////////////////////////////////////////// 01440 void SetOption(DirectoryOptions option, const std::wstring & path); 01441 /////////////////////////////////////////////////////////////////////////////// 01442 /// Sets a scrub option 01443 /// @param option One of the values in ScrubOptions 01444 /// @param action One of the values in Actions 01445 /////////////////////////////////////////////////////////////////////////////// 01446 void SetOption(ScrubOptions option, ScrubOptionActions action); 01447 /////////////////////////////////////////////////////////////////////////////// 01448 /// Sets an analyze option 01449 /// @param option One of the values in AnalyzeOptions 01450 /// @param action One of the values in Actions 01451 /////////////////////////////////////////////////////////////////////////////// 01452 void SetOption(AnalyzeOptions option, ScrubOptionActions action); 01453 /////////////////////////////////////////////////////////////////////////////// 01454 /// Sets a file format option 01455 /// @param option One of the values in FileFormatOptions 01456 /// @param format One of the values in FileFormats 01457 /////////////////////////////////////////////////////////////////////////////// 01458 void SetOption(FileFormatOptions option, FileFormats format); 01459 /////////////////////////////////////////////////////////////////////////////// 01460 /// Sets a file format list option 01461 /// @param option One of the values in FileFormatListOptions 01462 /// @param formats An array of FileFormats values 01463 /// @param count The number of items in the values array 01464 /////////////////////////////////////////////////////////////////////////////// 01465 void SetOption(FileFormatListOptions option, FileFormats formats[], int count); 01466 /////////////////////////////////////////////////////////////////////////////// 01467 /// Gets a boolean option 01468 /// @param option One of the values in BooleanOptions 01469 /// @return Value of the option 01470 /////////////////////////////////////////////////////////////////////////////// 01471 bool GetOption(BooleanOptions option); 01472 /////////////////////////////////////////////////////////////////////////////// 01473 /// Gets a integer option 01474 /// @param option One of the values in IntegerOptions 01475 /// @return Value of the option 01476 /////////////////////////////////////////////////////////////////////////////// 01477 BFINT64 GetOption(IntegerOptions option); 01478 /////////////////////////////////////////////////////////////////////////////// 01479 /// Gets a string option 01480 /// @param option One of the values in StringOptions 01481 /// @param str String that will receive the value of the option 01482 /////////////////////////////////////////////////////////////////////////////// 01483 void GetOption(StringOptions option, std::wstring & str); 01484 /////////////////////////////////////////////////////////////////////////////// 01485 /// Gets a file option. This will only work on file options set using 01486 /// a file path. The results are unknown on file options set using 01487 /// memory or a BFChannel. 01488 /// @param option One of the values in FileOptions 01489 /// @param path String that will receive the path to the file 01490 /////////////////////////////////////////////////////////////////////////////// 01491 void GetOption(FileOptions option, std::wstring & path); 01492 /////////////////////////////////////////////////////////////////////////////// 01493 /// Gets a scrub option. 01494 /// @param option One of the values in ScrubOptions 01495 /// @return The value of the option. Will be one of the value in Actions. 01496 /////////////////////////////////////////////////////////////////////////////// 01497 ScrubOptionActions GetOption(ScrubOptions option); 01498 /////////////////////////////////////////////////////////////////////////////// 01499 /// Gets a analyze option. 01500 /// @param option One of the values in AnalyzeOptions 01501 /// @return The value of the option. Will be one of the value in Actions. 01502 /////////////////////////////////////////////////////////////////////////////// 01503 ScrubOptionActions GetOption(AnalyzeOptions option); 01504 /////////////////////////////////////////////////////////////////////////////// 01505 /// Gets a file format option. 01506 /// @param option One of the values in FileFormatOptions 01507 /// @return The value of the option. Will be one of the value in FileFormats. 01508 /////////////////////////////////////////////////////////////////////////////// 01509 FileFormats GetOption(FileFormatOptions option); 01510 /////////////////////////////////////////////////////////////////////////////// 01511 /// Gets a file format list option 01512 /// @param option One of the values in FileFormatListOptions 01513 /// @param formats An array of FileFormats values 01514 /// @param count count 01515 /////////////////////////////////////////////////////////////////////////////// 01516 void GetOption(FileFormatListOptions option, FileFormats formats[], int * count); 01517 /////////////////////////////////////////////////////////////////////////////// 01518 /// Read options stored in an XML file. The file must have been previously 01519 /// saved using WriteOptionsToXML. 01520 /// @param path Full path to the XML file to read. 01521 /////////////////////////////////////////////////////////////////////////////// 01522 void ReadOptionsFromXML(std::wstring & path); 01523 /////////////////////////////////////////////////////////////////////////////// 01524 /// Write the current options to an XML file. 01525 /// @param path Full path to the XML file to write. 01526 /////////////////////////////////////////////////////////////////////////////// 01527 void WriteOptionsToXML(std::wstring & path); 01528 }; 01529 01530 #include "extracthandlercpp.generated.h" 01531 01532 01533 /////////////////////////////////////////////////////////////////////////////// 01534 /// An object that represents a reusable request to preform analysis and/or 01535 /// scrubbing. A single instance of this object should be created and reused 01536 /// to process many documents. 01537 /////////////////////////////////////////////////////////////////////////////// 01538 class BFSecureRequest : public BFOptionSet 01539 { 01540 public: 01541 /////////////////////////////////////////////////////////////////////////////// 01542 /// Constructs a BFSecureRequest object 01543 /////////////////////////////////////////////////////////////////////////////// 01544 BFSecureRequest(); 01545 /////////////////////////////////////////////////////////////////////////////// 01546 /// Destroys a BFSecureRequest object 01547 /////////////////////////////////////////////////////////////////////////////// 01548 ~BFSecureRequest(); 01549 /////////////////////////////////////////////////////////////////////////////// 01550 /// Execute the secure request. Executes a request to analyze or scrub a 01551 /// document. Use the SetOption methods to setup the request before 01552 /// calling this function. 01553 /////////////////////////////////////////////////////////////////////////////// 01554 void Execute(); 01555 /////////////////////////////////////////////////////////////////////////////// 01556 /// Gets a BGSecureResponse object that contains the response to the most 01557 /// recent call to BFSecureRequest::Execute. 01558 /// @return Pointer to a BFSecureResponse object. This objects lifetime is 01559 /// under developer control and is not bound to BFSecureRequest 01560 /// object from which it is retrieved. The developer must delete 01561 /// the object when finished using it. 01562 /////////////////////////////////////////////////////////////////////////////// 01563 BFSecureResponse * GetSecureResponse(); 01564 /////////////////////////////////////////////////////////////////////////////// 01565 /// Initialize the API. Must be called before calling any other static 01566 /// methods or creating any Clean Content objects. 01567 /// Must only be called once per process. 01568 /// @param features Reserved for future use. Must be 0 01569 /////////////////////////////////////////////////////////////////////////////// 01570 static void Startup(int features); 01571 /////////////////////////////////////////////////////////////////////////////// 01572 /// Clean up the API. Must be called after all use of this API is complete. 01573 /// Must be called from the same thread that called BFSecureRequest::Startup(). 01574 /////////////////////////////////////////////////////////////////////////////// 01575 static void Shutdown(); 01576 /////////////////////////////////////////////////////////////////////////////// 01577 /// Start using this API in a new thread. Must be called for each new thread 01578 /// that will use this API, not including the thread in which 01579 /// BFSecureRequest::Startup() is called. Threads that call this method must 01580 /// call BFSecureRequest::DetachThread() before BFSecureRequest::Shutdown() is 01581 /// called. 01582 /////////////////////////////////////////////////////////////////////////////// 01583 static void AttachThread(); 01584 /////////////////////////////////////////////////////////////////////////////// 01585 /// Finish using this API in a thread. Must be called for each thread that 01586 /// called BFSecureRequest::AttachThread() after the thread has finished 01587 /// using this API. 01588 /////////////////////////////////////////////////////////////////////////////// 01589 static void DetachThread(); 01590 /////////////////////////////////////////////////////////////////////////////// 01591 /// Gets the id for an option. 01592 /// @param option One of the values in ScrubOptions, AnalyzeOptions, 01593 /// BooleanOptions, FileFormatOptions or FileOptions 01594 /// @param name String that will receive the id 01595 /////////////////////////////////////////////////////////////////////////////// 01596 static void GetOptionId(int option, std::wstring & name); 01597 /////////////////////////////////////////////////////////////////////////////// 01598 /// Gets the name for an option. 01599 /// @param option One of the values in ScrubOptions, AnalyzeOptions, 01600 /// BooleanOptions, FileFormatOptions or FileOptions 01601 /// @param name String that will receive the name 01602 /////////////////////////////////////////////////////////////////////////////// 01603 static void GetOptionName(int option, std::wstring & name); 01604 /////////////////////////////////////////////////////////////////////////////// 01605 /// Gets the short description for an option. 01606 /// @param option One of the values in ScrubOptions, AnalyzeOptions, 01607 /// BooleanOptions, FileFormatOptions or FileOptions 01608 /// @param description String that will receive the description 01609 /////////////////////////////////////////////////////////////////////////////// 01610 static void GetOptionShortDescription(int option, std::wstring & description); 01611 /////////////////////////////////////////////////////////////////////////////// 01612 /// Gets the long description for an option. 01613 /// @param option One of the values in ScrubOptions, AnalyzeOptions, 01614 /// BooleanOptions, FileFormatOptions or FileOptions 01615 /// @param description String that will receive the description 01616 /////////////////////////////////////////////////////////////////////////////// 01617 static void GetOptionLongDescription(int option, std::wstring & description); 01618 /////////////////////////////////////////////////////////////////////////////// 01619 /// Gets the name for a file format 01620 /// @param format One of the values in FileFormats 01621 /// @param name String that will receive the name 01622 /////////////////////////////////////////////////////////////////////////////// 01623 static void GetFileFormatName(const FileFormats format, std::wstring & name); 01624 /////////////////////////////////////////////////////////////////////////////// 01625 /// Gets the description for a file format 01626 /// @param format One of the values in FileFormats 01627 /// @param description String that will receive the description 01628 /////////////////////////////////////////////////////////////////////////////// 01629 static void GetFileFormatDescription(const FileFormats format, std::wstring & description); 01630 /////////////////////////////////////////////////////////////////////////////// 01631 /// Gets the extension associated with a file format 01632 /// @param format One of the values in FileFormats 01633 /// @param extension String that will receive the extension 01634 /////////////////////////////////////////////////////////////////////////////// 01635 static void GetFileFormatExtension(const FileFormats format, std::wstring & extension); 01636 }; 01637 01638 01639 01640 #ifdef BFDEFINECPP 01641 01642 inline void BFSecureResponse::HandleError(int error, BFHANDLE errorinfo) { 01643 if (error == BFRESULT_OK) 01644 { 01645 return; 01646 } 01647 else if (errorinfo != NULL) 01648 { 01649 /* 01650 std::wstring msg(BFGetErrorMessage(errorinfo)); 01651 std::wstring ext(BFGetExtendedErrorMessage(errorinfo)); 01652 BFCloseErrorInfo(errorinfo); 01653 throw BFTransformException(msg,ext); 01654 */ 01655 throw BFTransformException(errorinfo); 01656 } 01657 else if (error == BFRESULT_FAIL) 01658 { 01659 throw BFTransformException(L"Method failed",L"Method failed"); 01660 } 01661 else if (error == BFRESULT_INVALIDARG) 01662 { 01663 throw BFTransformException(L"Invalid argument",L"Invalid argument"); 01664 } 01665 else if (error == BFRESULT_INVALIDHANDLE) 01666 { 01667 throw BFTransformException(L"Invalid handle",L"Invalid handle"); 01668 } 01669 else 01670 { 01671 throw BFTransformException(); 01672 } 01673 } 01674 01675 inline BFSecureResponse::BFSecureResponse(BFHANDLE res) { 01676 response = res; 01677 } 01678 01679 inline BFSecureResponse::~BFSecureResponse() { 01680 BFCloseSecureResponse(response,NULL); 01681 } 01682 01683 inline bool BFSecureResponse::GetBooleanResult(BooleanOptions option) { 01684 int result; 01685 BFHANDLE errorinfo; 01686 int error; 01687 if ((error = BFGetBooleanResult(response,option,&result,&errorinfo)) != BFRESULT_OK) { 01688 HandleError(error,errorinfo); 01689 } 01690 01691 return result ? BFTRUE : BFFALSE; 01692 } 01693 01694 inline int BFSecureResponse::GetEnumResult(EnumOptions option) { 01695 int result; 01696 BFHANDLE errorinfo; 01697 int error; 01698 if ((error = BFGetEnumResult(response,option,&result,&errorinfo)) != BFRESULT_OK) { 01699 HandleError(error,errorinfo); 01700 } 01701 01702 return result; 01703 } 01704 01705 inline ScrubOptionReactions BFSecureResponse::GetScrubResult(ScrubOptions option) { 01706 ScrubOptionReactions result; 01707 BFHANDLE errorinfo; 01708 int error; 01709 if ((error = BFGetScrubResult(response,option,&result,&errorinfo)) != BFRESULT_OK) { 01710 HandleError(error,errorinfo); 01711 } 01712 return result; 01713 } 01714 01715 inline ScrubOptionReactions BFSecureResponse::GetAnalyzeResult(AnalyzeOptions option) { 01716 ScrubOptionReactions result; 01717 BFHANDLE errorinfo; 01718 int error; 01719 if ((error = BFGetAnalyzeResult(response,option,&result,&errorinfo)) != BFRESULT_OK) { 01720 HandleError(error,errorinfo); 01721 } 01722 return result; 01723 } 01724 01725 inline FileFormats BFSecureResponse::GetFileFormatResult(FileFormatOptions option) { 01726 FileFormats result; 01727 BFHANDLE errorinfo; 01728 int error; 01729 if ((error = BFGetFileFormatResult(response,option,&result,&errorinfo)) != BFRESULT_OK) { 01730 HandleError(error,errorinfo); 01731 } 01732 return result; 01733 } 01734 01735 class BFElementHandler; 01736 01737 inline void BFOptionSet::HandleError(int error, BFHANDLE errorinfo) { 01738 01739 if (error == BFRESULT_OK) { 01740 return; 01741 } else if (errorinfo != NULL) 01742 { 01743 //std::wstring msg(BFGetErrorMessage(errorinfo)); 01744 //std::wstring ext(BFGetExtendedErrorMessage(errorinfo)); 01745 //BFCloseErrorInfo(errorinfo); 01746 throw BFTransformException(errorinfo); 01747 } 01748 else if (error == BFRESULT_FAIL) 01749 { 01750 throw BFTransformException(L"Method failed",L"Method failed"); 01751 } 01752 else if (error == BFRESULT_INVALIDARG) 01753 { 01754 throw BFTransformException(L"Invalid argument",L"Invalid argument"); 01755 } 01756 else if (error == BFRESULT_INVALIDHANDLE) 01757 { 01758 throw BFTransformException(L"Invalid handle",L"Invalid handle"); 01759 } 01760 else 01761 { 01762 throw BFTransformException(); 01763 } 01764 } 01765 01766 inline BFOptionSet::BFOptionSet() {} 01767 01768 inline BFOptionSet::BFOptionSet(const BFHANDLE optionset) { 01769 request = (BFHANDLE)optionset; 01770 } 01771 01772 inline BFOptionSet::~BFOptionSet() {} 01773 01774 inline bool BFOptionSet::IsValid() { 01775 return (request != 0); 01776 } 01777 01778 inline void BFOptionSet::SetOption(BooleanOptions option, const bool value) { 01779 BFHANDLE errorinfo; 01780 int error; 01781 if ((error = BFSetBooleanOption(request,option,value ? BFTRUE : BFFALSE,&errorinfo)) != BFRESULT_OK) { 01782 HandleError(error,errorinfo); 01783 } 01784 } 01785 01786 inline void BFOptionSet::SetOption(IntegerOptions option, const int value) { 01787 BFHANDLE errorinfo; 01788 int error; 01789 if ((error = BFSetIntegerOption(request,option,value,&errorinfo)) != BFRESULT_OK) { 01790 HandleError(error,errorinfo); 01791 } 01792 } 01793 01794 inline void BFOptionSet::SetOption(DateOptions option, const int year, const int month, const int day, const int hour, const int minute, const int second) { 01795 BFHANDLE errorinfo; 01796 int error; 01797 if ((error = BFSetDateOption(request,option, year, month, day, hour, minute, second, &errorinfo)) != BFRESULT_OK) { 01798 HandleError(error,errorinfo); 01799 } 01800 } 01801 01802 inline void BFOptionSet::SetOption(DurationOptions option, const int value) { 01803 BFHANDLE errorinfo; 01804 int error; 01805 if ((error = BFSetDurationOption(request,option,value,&errorinfo)) != BFRESULT_OK) { 01806 HandleError(error,errorinfo); 01807 } 01808 } 01809 01810 inline void BFOptionSet::SetOption(EnumOptions option, const int value) { 01811 BFHANDLE errorinfo; 01812 int error; 01813 if ((error = BFSetEnumOption(request,option,value,&errorinfo)) != BFRESULT_OK) { 01814 HandleError(error,errorinfo); 01815 } 01816 } 01817 01818 inline void BFOptionSet::SetOption(EnumListOptions option, const int values[], const int count) { 01819 BFHANDLE errorinfo; 01820 int error; 01821 if ((error = BFSetEnumListOption(request,option,values,count,&errorinfo)) != BFRESULT_OK) { 01822 HandleError(error,errorinfo); 01823 } 01824 } 01825 01826 inline void BFOptionSet::SetOption(StringOptions option, const std::wstring & str) { 01827 BFHANDLE errorinfo; 01828 int error; 01829 if ((error = BFSetStringOption(request,option,str.c_str(),&errorinfo)) != BFRESULT_OK) { 01830 HandleError(error,errorinfo); 01831 } 01832 } 01833 01834 01835 inline void BFOptionSet::SetOption(StringListOptions option, const std::wstring strs[], const int count) { 01836 BFHANDLE errorinfo; 01837 int error; 01838 01839 const wchar_t * * cstrs = new const wchar_t *[count]; 01840 01841 for (int i = 0; i < count; i++) { 01842 cstrs[i] = strs[i].c_str(); 01843 } 01844 01845 error = BFSetStringListOption(request,option,cstrs,count,&errorinfo); 01846 01847 delete[] cstrs; 01848 01849 if (error != BFRESULT_OK) { 01850 HandleError(error,errorinfo); 01851 } 01852 } 01853 01854 inline void BFOptionSet::SetOption(FileOptions option, const std::wstring & path) { 01855 BFHANDLE errorinfo; 01856 int error; 01857 if ((error = BFSetFileOption(request,option,path.c_str(),&errorinfo)) != BFRESULT_OK) { 01858 HandleError(error,errorinfo); 01859 } 01860 } 01861 01862 inline void BFOptionSet::SetOption(FileOptions option, void * memory, const long length) { 01863 BFHANDLE errorinfo; 01864 int error; 01865 if ((error = BFSetFileOptionUsingMemory(request,option,memory,length,&errorinfo)) != BFRESULT_OK) { 01866 HandleError(error,errorinfo); 01867 } 01868 } 01869 01870 inline void BFOptionSet::SetOption(FileOptions option, BFChannel * channel) { 01871 01872 BFCPPCHANNEL * CppChannel = new BFCPPCHANNEL; 01873 CppChannel->channelObj = channel; 01874 /* 01875 CppChannel->channel.close = BFCppChannelClose; 01876 CppChannel->channel.read = BFCppChannelRead; 01877 CppChannel->channel.write = BFCppChannelWrite; 01878 CppChannel->channel.size = BFCppChannelSize; 01879 CppChannel->channel.supports = BFCppChannelSupports; 01880 */ 01881 InitChannelForCpp(&(CppChannel->channel)); 01882 01883 BFHANDLE errorinfo; 01884 int error; 01885 01886 if ((error = BFSetFileOptionUsingChannel(request,option,(BFCHANNEL *)CppChannel,&errorinfo)) != BFRESULT_OK) { 01887 delete CppChannel; 01888 HandleError(error,errorinfo); 01889 } 01890 } 01891 01892 inline void BFOptionSet::SetOption(HandlerOptions option, BFElementHandler * eh) { 01893 BFCPPELEMENTHANDLER * CppEh = new BFCPPELEMENTHANDLER; 01894 CppEh->ehObj = eh; 01895 InitElementHandlerForCpp(&(CppEh->eh)); 01896 BFHANDLE errorinfo; 01897 int error; 01898 01899 if ((error = BFSetHandlerOption(request,option,(BFELEMENTHANDLER *)CppEh,&errorinfo)) != BFRESULT_OK) { 01900 delete CppEh; 01901 HandleError(error,errorinfo); 01902 } 01903 } 01904 01905 01906 inline void BFOptionSet::SetOption(DirectoryOptions option, const std::wstring & path) { 01907 BFHANDLE errorinfo; 01908 int error; 01909 if ((error = BFSetDirectoryOption(request,option,path.c_str(),&errorinfo)) != BFRESULT_OK) { 01910 HandleError(error,errorinfo); 01911 } 01912 } 01913 01914 inline void BFOptionSet::SetOption(ScrubOptions option, ScrubOptionActions action) { 01915 BFHANDLE errorinfo; 01916 int error; 01917 if ((error = BFSetScrubOption(request,option,action,&errorinfo)) != BFRESULT_OK) { 01918 HandleError(error,errorinfo); 01919 } 01920 } 01921 01922 inline void BFOptionSet::SetOption(AnalyzeOptions option, ScrubOptionActions action) { 01923 BFHANDLE errorinfo; 01924 int error; 01925 if ((error = BFSetAnalyzeOption(request,option,action,&errorinfo)) != BFRESULT_OK) { 01926 HandleError(error,errorinfo); 01927 } 01928 } 01929 01930 inline void BFOptionSet::SetOption(FileFormatOptions option, FileFormats format) { 01931 BFHANDLE errorinfo; 01932 int error; 01933 01934 if ((error = BFSetFileFormatOption(request,option,format,&errorinfo)) != BFRESULT_OK) { 01935 HandleError(error,errorinfo); 01936 } 01937 } 01938 01939 inline void BFOptionSet::SetOption(FileFormatListOptions option, FileFormats formats[], int count) { 01940 BFHANDLE errorinfo; 01941 int error; 01942 01943 if ((error = BFSetFileFormatListOption(request,option,formats,count,&errorinfo)) != BFRESULT_OK) { 01944 HandleError(error,errorinfo); 01945 } 01946 } 01947 01948 inline bool BFOptionSet::GetOption(BooleanOptions option) { 01949 int result; 01950 BFHANDLE errorinfo; 01951 int error; 01952 if ((error = BFGetBooleanOption(request,option,&result,&errorinfo)) != BFRESULT_OK) { 01953 HandleError(error,errorinfo); 01954 } 01955 01956 return (result == BFTRUE); 01957 } 01958 01959 inline BFINT64 BFOptionSet::GetOption(IntegerOptions option) { 01960 BFINT64 result; 01961 BFHANDLE errorinfo; 01962 int error; 01963 if ((error = BFGetIntegerOption(request,option,&result,&errorinfo)) != BFRESULT_OK) { 01964 HandleError(error,errorinfo); 01965 } 01966 return result; 01967 } 01968 01969 inline void BFOptionSet::GetOption(StringOptions option, std::wstring & str) { 01970 wchar_t buf[1024]; 01971 BFHANDLE errorinfo; 01972 int error; 01973 if ((error = BFGetStringOption(request,option,buf,1024,&errorinfo)) != BFRESULT_OK) { 01974 HandleError(error,errorinfo); 01975 } 01976 str = buf; 01977 } 01978 01979 inline void BFOptionSet::GetOption(FileOptions option, std::wstring & path) { 01980 wchar_t buf[1024]; 01981 BFHANDLE errorinfo; 01982 int error; 01983 if ((error = BFGetFileOption(request,option,buf,1024,&errorinfo)) != BFRESULT_OK) { 01984 HandleError(error,errorinfo); 01985 } 01986 path = buf; 01987 } 01988 01989 inline ScrubOptionActions BFOptionSet::GetOption(ScrubOptions option) { 01990 ScrubOptionActions result; 01991 BFHANDLE errorinfo; 01992 int error; 01993 if ((error = BFGetScrubOption(request,option,&result,&errorinfo)) != BFRESULT_OK) { 01994 HandleError(error,errorinfo); 01995 } 01996 return result; 01997 } 01998 01999 inline ScrubOptionActions BFOptionSet::GetOption(AnalyzeOptions option) { 02000 ScrubOptionActions result; 02001 BFHANDLE errorinfo; 02002 int error; 02003 if ((error = BFGetAnalyzeOption(request,option,&result,&errorinfo)) != BFRESULT_OK) { 02004 HandleError(error,errorinfo); 02005 } 02006 return result; 02007 } 02008 02009 inline FileFormats BFOptionSet::GetOption(FileFormatOptions option) { 02010 FileFormats result; 02011 BFHANDLE errorinfo; 02012 int error; 02013 if ((error = BFGetFileFormatOption(request,option,&result,&errorinfo)) != BFRESULT_OK) { 02014 HandleError(error,errorinfo); 02015 } 02016 return result; 02017 } 02018 02019 inline void BFOptionSet::GetOption(FileFormatListOptions option, FileFormats formats[], int * count) { 02020 BFHANDLE errorinfo; 02021 int error; 02022 02023 if ((error = BFGetFileFormatListOption(request,option,formats,count,&errorinfo)) != BFRESULT_OK) { 02024 HandleError(error,errorinfo); 02025 } 02026 } 02027 02028 inline void BFOptionSet::ReadOptionsFromXML(std::wstring & path) { 02029 BFHANDLE errorinfo; 02030 int error; 02031 if ((error = BFReadOptionsFromXML(request,path.c_str(),&errorinfo)) != BFRESULT_OK) { 02032 HandleError(error,errorinfo); 02033 } 02034 } 02035 02036 inline void BFOptionSet::WriteOptionsToXML(std::wstring & path) { 02037 BFHANDLE errorinfo; 02038 int error; 02039 if ((error = BFWriteOptionsToXML(request,path.c_str(),&errorinfo)) != BFRESULT_OK) { 02040 HandleError(error,errorinfo); 02041 } 02042 } 02043 02044 inline BFSecureRequest::BFSecureRequest() { 02045 BFHANDLE errorinfo; 02046 int error; 02047 if ((error = BFOpenSecureRequest(&request,&errorinfo)) != BFRESULT_OK) { 02048 HandleError(error,errorinfo); 02049 } 02050 } 02051 02052 inline BFSecureRequest::~BFSecureRequest() { 02053 BFCloseSecureRequest(request,NULL); 02054 } 02055 02056 inline void BFSecureRequest::Execute() { 02057 BFHANDLE errorinfo; 02058 int error; 02059 if ((error = BFExecuteSecureRequest(request,&errorinfo)) != BFRESULT_OK) { 02060 HandleError(error,errorinfo); 02061 } 02062 } 02063 02064 inline BFSecureResponse * BFSecureRequest::GetSecureResponse() { 02065 BFHANDLE response; 02066 BFHANDLE errorinfo; 02067 int error; 02068 if ((error = BFGetSecureResponse(request,&response,&errorinfo)) != BFRESULT_OK) { 02069 HandleError(error,errorinfo); 02070 } 02071 return new BFSecureResponse(response); 02072 } 02073 02074 inline void BFSecureRequest::Startup(int features) { 02075 if (BFStartup(features) != BFRESULT_OK) { 02076 throw BFTransformException(std::wstring(L"BFStartup failed"),std::wstring(L"BFStartup failed")); 02077 } 02078 } 02079 02080 inline void BFSecureRequest::Shutdown() { 02081 BFShutdown(); 02082 } 02083 02084 inline void BFSecureRequest::AttachThread() { 02085 BFAttachThread(); 02086 } 02087 02088 inline void BFSecureRequest::DetachThread() { 02089 BFDetachThread(); 02090 } 02091 02092 inline void BFSecureRequest::GetOptionId(int option, std::wstring & id) { 02093 wchar_t buf[1024]; 02094 BFHANDLE errorinfo; 02095 int error; 02096 if ((error = BFGetOptionId(option,buf,1024,&errorinfo)) != BFRESULT_OK) { 02097 HandleError(error,errorinfo); 02098 } 02099 id = buf; 02100 } 02101 02102 inline void BFSecureRequest::GetOptionName(int option, std::wstring & name) { 02103 wchar_t buf[1024]; 02104 BFHANDLE errorinfo; 02105 int error; 02106 if ((error = BFGetOptionName(option,buf,1024,&errorinfo)) != BFRESULT_OK) { 02107 HandleError(error,errorinfo); 02108 } 02109 name = buf; 02110 } 02111 02112 inline void BFSecureRequest::GetOptionShortDescription(int option, std::wstring & description) { 02113 wchar_t buf[1024]; 02114 BFHANDLE errorinfo; 02115 int error; 02116 if ((error = BFGetOptionShortDescription(option,buf,1024,&errorinfo)) != BFRESULT_OK) { 02117 HandleError(error,errorinfo); 02118 } 02119 description = buf; 02120 } 02121 02122 inline void BFSecureRequest::GetOptionLongDescription(int option, std::wstring & description) { 02123 wchar_t buf[10240]; 02124 BFHANDLE errorinfo; 02125 int error; 02126 if ((error = BFGetOptionLongDescription(option,buf,10240,&errorinfo)) != BFRESULT_OK) { 02127 HandleError(error,errorinfo); 02128 } 02129 description = buf; 02130 } 02131 02132 inline void BFSecureRequest::GetFileFormatName(const FileFormats format, std::wstring & name) { 02133 wchar_t buf[1024]; 02134 BFHANDLE errorinfo; 02135 int error; 02136 if ((error = BFGetFileFormatName(format,buf,1024,&errorinfo)) != BFRESULT_OK) { 02137 HandleError(error,errorinfo); 02138 } 02139 name = buf; 02140 } 02141 02142 inline void BFSecureRequest::GetFileFormatDescription(const FileFormats format, std::wstring & description) { 02143 wchar_t buf[1024]; 02144 BFHANDLE errorinfo; 02145 int error; 02146 if ((error = BFGetFileFormatDescription(format,buf,1024,&errorinfo)) != BFRESULT_OK) { 02147 HandleError(error,errorinfo); 02148 } 02149 description = buf; 02150 } 02151 02152 inline void BFSecureRequest::GetFileFormatExtension(const FileFormats format, std::wstring & extension) { 02153 wchar_t buf[1024]; 02154 BFHANDLE errorinfo; 02155 int error; 02156 if ((error = BFGetFileFormatExtension(format,buf,1024,&errorinfo)) != BFRESULT_OK) { 02157 HandleError(error,errorinfo); 02158 } 02159 extension = buf; 02160 } 02161 02162 #endif // BFDEFINECPP 02163 #endif // __cplusplus 02164 02165 /// @mainpage Clean Content C/C++ API 02166 /// 02167 /// @section intro_sec Introduction 02168 /// This API allows C or C++ developers to access Clean Content's<br/> 02169 /// document analysis, scrubbing and extraction functionallity. 02170 /// 02171 /// The C and C++ API's are presented togther because the C++<br/> 02172 /// API is simply a thin shell (implemented as header-only classes)<br/> 02173 /// on top of the C API and reuses many of the C API's constructs. 02174 /// 02175 /// @section use_sec Usage 02176 /// Using this API requires including the header file secureapi.h,<br/> 02177 /// linking with CleanContentAPI.dll or CleanContentAPI.so and 02178 /// several other steps. Please see the <a href="../../index.html">Developer's Guide</a><br/> 02179 /// for more information. 02180 /// 02181 /// @section devguide_sec Developer's Guide 02182 /// If you have not already done so we urge you to begin your review<br/> 02183 /// of this API by reading the <a href="../../index.html">Developer's Guide</a>. It contain all the<br/> 02184 /// overview, details and code examples that one might expect to find<br/> 02185 /// here. The <a href="../../index.html">Developer's Guide</a> is seperate in order to document<br/> 02186 /// in a single location the information common to the C, C++, Java<br/> 02187 /// and .NET APIs. 02188 /// 02189