MivaScript Functions

abs( number )

asciichar( number )

asin( number )

atan2( x, y )

bf_encrypt( key, plaintext, encrypted var )

• key = the encryption key in ECB mode. The key must be 16 characters.
• plaintext = the text thats encrypted
• encrypted = if sucessful it will contain the results

cos( number )

crypto_base64_decode( data )

• data = the information to decode

crypto_cipher_block_size( ciphername )

• ciphername = an OpenSSL cipher identifier, such as "aes-128-cbc" or "rc2-ofb".

crypto_cipher_key_length( ciphername )

• ciphername = an OpenSSL cipher identifier, such as "aes-128-cbc" or "rc2-ofb".

crypto_digest_block_size( digestname )

• digestname = an OpenSSL digest identifier, such as "sha256" or "md5".

crypto_evp_decrypt( ciphername, key, iv, encrypted, plaintext var )

• ciphername = The OpenSSL identifier of the cipher, such as "bf-cbc" or "des-ede3-cbc".
• key = The key used for encryption.
• iv = The initialization vector used for encryption. returned by crypto_cipher_iv_length().
• encrypted = The ciphertext to be decrypted
• plaintext = [output] Receives the plaintext

crypto_evp_encrypt( ciphername, key, iv, plaintext, encrypted var )

• ciphername = The OpenSSL identifier of the cipher, such as "bf-cbc" or "des-ede3-cbc".
• key = The encryption key. Must be exactly the number of bytes required by the cipher, as returned by crypto_cipher_key_length.
• iv = An initialization vector, if required by the cipher. Must be exactly the number of bytes required by the cipher, as returned by crypto_cipher_iv_length.
• plaintext = The text to be encrypted
• encrypted = [output] Receives the cipher text

crypto_evp_hmac( digestname, key, buffer var, digest var )

• digestname = an OpenSSL digest identifier, such as "sha256" or "md5".
• buffer = The data that will be process.
• digest = The result of the HMAC function.

crypto_hmac_sha1( value, key, output_format, output)

• value = value to hash by reference
• key = key to use to calculate the hmac
• output_format = 'hex' or 'binary'
• output = hmac_sha1 hash value.

crypto_last_error()

crypto_library_version( info )

crypto_md5_file( file, location, hash var )

• file = Name of file to calculate the hash of
• location = Location either "script" or "data"
• hash = MD5 hash value

crypto_pbkdf2( digestname, password, salt, iterations, dklen, dk var )

• digestname = The digest algorithm to use. May be any of the digests supported by the installed OpenSSL version.
• password = The password from which a key is to be derived.
• salt = Random data of any length that is used to salt the derivation. RFC 2898 recommends a minimum salt length of 8 bytes.
• iterations = The number of iterations to perform. RFC 2898 recommends at least 1000 iterations.
• dklen = The desired output length of the derived key. May be any positive value.
• dk = [output] Receives the derived key. The output is in raw binary.

crypto_rand_set_rand_engine( engine )

• engine = Name of the random number generator engine to use.

crypto_sha256( buffer var, format, result var )

• buffer = value to hash by reference
• output_format = 'hex' or 'binary'. Anything else will result in binary output.
• output = returned sha1 hash value.

decodeattribute( attribute )

dir( path, location, entries var )

• path = The path to a directory relative to the location
• location = "data" or "script"
• entries = array of resultant file names

encodeentities( string )

evp_pkey_derive( privkey var, peer var, key var )

• privkey = EVP PKEY structure reference
• peer = EVP PKEY structure reference
• key = Returned text of shared secret key

evp_pkey_load_mem( data, format, passphrase, pkey var )

• data = EVP PKEY structure text
• format = Format of the PKEY structure text. Only "pkcs12" is supported
• passphrase = Passphrase for the PKEY structure
• pkey = Structure reference

exp( number )

fcopy( source, destination )

• source = source file fully qualified path
• destination = destination file fully qualified path

fexists( path )

• path = the fully qualified path to the file

file_create( path, location, outputdata var )

• path = fully qualified path to the file
• location = location of the output file - 'data' or 'script'
• outputdata = string variable containing the data to append

file_read_bytes( path, location, offset, length, data )

• path = The name or filepath of the file to open relative to the directory specified by "location"
• location = One of "script" or "data"
• offset = The zero-based offset at which to begin reading
• length = The number of bytes to read. If < 0, the entire file after "offset" is read.
• data = The variable in which to store the file data

fisdir( path )

• path = the fully qualified path to the directory

fmkdir( path )

• path = the fully qualified path to the directory

fmode( path )

• path = the fully qualified path to the file or directory

fscopy( data_source,script_destination )

• data_source = source file fully qualified path
• scripts_destination = destination file fully qualified path

fsrename( source, destination )

• source = source file fully qualified path
• destination = destination file fully qualified path

fsymlink( source, destination )

• source = source file fully qualified path
• destination = destination file fully qualified path

gdClearLastError()

gdImageAlpha( im, c )

gdImageArc( im, cx, cy, w, h, s, e, color )

gdImageBoundsSafe( im, x, y )

gdImageColorAllocateAlpha( im, r, g, b, a )

gdImageColorClosestAlpha( im, r, g, b, a )

gdImageColorDeallocate( im, color )

gdImageColorExactAlpha( im, r, g, b, a )

gdImageColorResolveAlpha( im, r, g, b, a )

gdImageColorTransparent( im, color )

gdImageCopy( dst, src, dstX, dstY, srcX, srcY, w, h )

gdImageCopyMergeGray( dst, src, dstX, dstY, srcX, srcY, w, h, pct )

gdImageCopyResized( dst, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH )

gdImageCreate( sx, sy )

gdImageCreateFromGd2( filename, location )

gdImageCreateFromGd2Part( filename, location, srcx, srcy, w, h )

gdImageCreateFromGdMem( data var )

gdImageCreateFromGifMem( data var )

gdImageCreateFromJpegMem( data var )

gdImageCreateFromPngMem( data var )

gdImageCreateFromWBMPMem( data var )

gdImageCreateTrueColor( sx, sy )

gdImageDestroy( im )

gdImageFill( im, x, y, color )

gdImageFilledEllipse( im, cx, cy, w, h, color )

gdImageFilledRectangle( im, x1, y1, x2, y2, color )

gdImageGetClip( im, x1P var, y1P var, x2P var, y2P var )

gdImageGetPixel( im, x, y )

gdImageGetTrueColorPixel( im, x, y )

gdImageGifAnimAdd( im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm )

gdImageGifAnimAddOutput( im, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm )

gdImageGifAnimBeginMem( im, GlobalCM, Loops )

gdImageGifAnimEnd( out )

gdImageGifAnimEndOutput()

gdImageGifOutput( im )

gdImageInterlace( im, interlaceArg )

gdImageJpegMem( im, output var, quality )

gdImageLine( im, x1, y1, x2, y2, color )

gdImagePaletteCopy( dst, src )

gdImagePng( im, filename, location )

gdImagePngOutput( im )

gdImageRectangle( im, x1, y1, x2, y2, color )

gdImageSaveAlpha( im, saveAlphaArg )

gdImageSetAntiAliasedDontBlend( im, color, dont_blend )

gdImageSetClip( im, x1, y1, x2, y2 )

gdImageSetStyle( im, style var, n )

gdImageSetTile( im, tile )

gdImageSquareToCircle( im, radius )

gdImageStringFTCircle(
    im, cx, cy, radius, textRadius, fillPortion, font, points, top, bottom, fgcolor )

gdImageSY( im )

gdImageTrueColorPixel( im, x, y )

gdImageWBMP( im, fg, filename, location )

gdImageWBMPOutput( im, fg )

gdTrueColor( r, g, b )

gettoken( delimited_string, characters, position_num )

• delimited_string = A string delimited by a character or characters
• characters = the delimiter character or characters
• position_num = the position of the substring you want to return

glosub_array( string, search_array, replace_array )

• string = the target
• search_array = an array of strings that will be searched for
• replace_array = an array of the replacement strings

indexofi( search_string, target_string var, start_number )

• search_string = the string that will be searched for
• target_string = the string that will be searched
• start_number = the 1 based starting offset withing the target_string where the search will begin

indexofli( needle, haystack var, offset )

• needle var = Value to search for.
• haystack var = Text to search.
• offset = integer offset to start at.

isalnum( string )

• string = the characters tested

isascii( string )

• string = the characters tested

isdigit( string )

• string = the characters tested

islower( string )

• string = the characters tested

ispunct( string )

• string = the characters tested

isupper( string )

• string = the characters tested

keyword_extract( string, keywords var )

keyword_extract_merge_init()

keyword_in( keywords_array var, search_string )

len_var( string var )

• string = a literal string value embedded in single quotes or an expression that evaluates as a string.

log10( number )

makesessionid()

min( a, b )

• a = string or numeric value, b = string or numeric value

miva_array_clear( array var, start, count )

• array = The array that will be altered.
• start = the starting index numbert
• count = the number of elements that will be cleared

miva_array_copy( source var, sstart, scount, dest var, dpos )

• source = The source array from which records will be copied
• sstart = The source starting index
• scount = The number of source records to copy.
• dest = The destination array that will receive the copied records.
• dpos = The starting index within the destination array. Overlapping elements in "dest" are overwritten.

miva_array_delete( array var, start, count )

• array = The array that will be altered.
• start = the starting index numbert
• count = the number of elements that will be cleared

miva_array_elements( aggregate var )

miva_array_filter_ref( array var, offset, element var, filter_expression, output var )

• array var = Source array of structures.
• offset = index in the array to start filtering from.
• element var = Name of a variable to reference in the filter expression.
• filter_expression = Text of an expression to execute based on the individual array element.
• output var = Output array of all structures that tested true in the filter expression.

miva_array_insert( array var, element, pos )

• array = The array tro which the records will be inserted
• element = the record that will be inserted
• pos = the index where the element will be inserted.

miva_array_insert_var( array var, element var, pos )

• array = The array tro which the records will be inserted
• element = the record that will be inserted
• pos = the index where the element will be inserted.

miva_array_merge( source var, sstart, scount, dest var, dpos )

• source = The source array from which records will be copied
• sstart = The source starting index
• scount = The number of source records to copy.
• dest = The destination array that will receive the copied records.
• dpos = The starting index within the destination array. Existing elements in "dest" past "dpos" are pushed forward by "scount" elements.

miva_array_min( aggregate var )

miva_array_pop( array var )

• array = the array where the record will be remove.

miva_array_previous( aggregate var, index )

miva_array_serialize( aggregate var )

miva_array_shift_ref( array var, element var )

• array = the array where the record will be remove
• element = a reference to the element that was removed.

miva_async_sleep( until, semfile, semlocation )

• until = time_t (seconds since 1-JAN-1970) set in the future, the time to sleep until
• semfile = file name to watch
• semlocation = location of the file to watch. "script" or "data", defaulting to "data" if any other value.

miva_closelog()

miva_element_exists( array var, index )

miva_hex_decode( data )

• data = the hex data to decode.

miva_html_strip( text, allowed_tags )

• text = String to remove HTML tags from.
• allowed_tags = A comma-separated list of tags that will not be stripped from the string.

miva_json_decode( data, output var )

• data = The block of JSON encoded data that will be decoded
• output var = The function assigns the parsed aggregate to "output" as a structured array.

miva_lockfile( path, location )

• path = fully qualified path to the file
• location = location of the file - 'data' or 'script'
• Use fdelete() or sdelete() to delete the lockfile.

miva_openlog( ident, logopt, facility )

• ident = a string that will be prepended to all subsequent log messages. May be the empty string.
• logopt = a string containing a list of options. Each option may be any of the words listed below. Commas and/or spaces separate the options. An empty string is permitted.
• facility = The default facility code for subsequent messages. May be any one of the words listed below.

miva_output_header( header, value )

miva_setdefaultlanguage( language )

miva_setlogmask( maskpri )

• maskpri = a string containing a list of priorities. Each priority may be any of the words listed below. Commas and/or spaces separate the priorities. An empty string is permitted but means that all subsequent miva_writelog calls will be ignored.

miva_sleep( msecs )

• msecs = the number of milliseconds to delay

miva_struct_members( struct var, members var )

• struct = the structure or structured array that will be processed
• members = The array populated with the members names found in structure

miva_struct_merge_ref( source var, dest var )

• source - Structure to copy into dest.
• dest - Destination structure.

miva_template_compile_dump( source var, errors var )

miva_variable_type( variable )

• variable = a variable name

miva_writelog( priority, message )

• priority = a string containing a list of words. These words may be either a facility code (see miva_openlog) or a priority code (see miva_setlogmask). Commas and/or spaces separate the words. The facility may be omitted in which case the default will be assumed (see miva_openlog). If the priority is omitted or has been disabled via a call to miva_setlogmask, then the miva_writelog call will be ignored.
• message = a string that will be written to the log.

padl( string, length, character )

pkcs7_free( pkcs7 var )

• pkcs7 = PKCS7 structure reference

pkcs7_load_mem( cert, format, pkcs7 var )

• cert = Text of a list of pkcs7 structures
• format = Format of the structure(s) passed in. Valid values are "der", "pem", or "pkcs12", with "der" used if the format is missing or any other values are passed
• pkcs7 = Structure array reference. On success, this will be neither zero nor null

power( number, matissa )

rnd( value, precision )

rsa_generate_keypair( pubkey_file, privkey_file, bits, e, passphrase )

• pubkey_file = The name of the file in which the generated public key is stored
• privkey_file = The name of the file in which the generated private key is stored
• bits = The RSA modulus size, in bits
• e = The public key exponent. Must be an odd number, typically 3, 17 or 65537
• passphrase = The passphrase used to encrypt the private key

rsa_generate_keypair_mem_cipher( pubkey var, privkey var, bits, e, passphrase, ciphername )

• pubkey = The variable which receives the generated public key
• privkey = The variable which receives the generated private key
• bits = The RSA modulus size, in bits
• e = The public key exponent. Must be an odd number, typically 3, 17 or 65537
• passphrase = The passphrase used to encrypt the private key
• ciphername = an OpenSSL cipher identifier, such as "aes-128-cbc"

rsa_load_privatekey_engine( engine, key_id, rsa var )

• engine = Name of the encryption engine to use.
• key_id = identifier of the key to load
• rsa = RSA private key associated with the engine and key ID.

rsa_load_publickey( pubkey_file, rsa var )

• pubkey_file = The name of the file containing the public key
• rsa = A variable which receives an internal reference to the loaded RSA key

rsa_load_publickey_mem( pubkey, rsa var )

• pubkey = The public key in PKCS#1 format
• rsa = A variable which receives an internal reference to the loaded RSA key

rsa_private_encrypt( rsa, plaintext, encrypted var )

• rsa = The internal reference to the RSA private key used for encryption
• plaintext = The data to be encrypted
• encrypted = A variable which receives the encrypted ciphertext in raw binary format

rsa_public_encrypt( rsa, plaintext, encrypted var )

• rsa = The internal reference to the RSA public key used for encryption
• plaintext = The data to be encrypted
• encrypted = A variable which receives the encrypted ciphertext in raw binary format

rsa_save_privatekey_mem( privkey var, rsa var, passphrase )

• privkey = The variable which will receive the encrypted private key
• rsa = The internal reference to the RSA private key to be saved
• passphrase = The passphrase used to encrypt the private key

rsa_sign( rsa, buffer, signature var )

• rsa = The internal reference to the RSA private key to be used
• buffer = The data to be signed
• signature = A variable which receives the signature in raw binary format

rtrim( string )

scopy( source, destination )

• source = source file fully qualified path
• destination = destination file fully qualified path

sexists( path )

• path = the fully qualified path to the file.

sfrename( source, destination )

• source = source file fully qualified path
• destination = destination file fully qualified path

sin( number )

sisdir( path )

• path = the fully qualified path to the directory

smkdir( path )

• path = the fully qualified path to the directory

sqrt( number )

srename( source, destination )

• source = source file fully qualified path
• destination = destination file fully qualified path

ssymlink( source, destination )

• source = source file fully qualified path
• destination = destination file fully qualified path

substring( string, position, length )

tan( number )

tar_create( file, file_loc, dir, dir_loc, flags )

• file = target output file
• location = location of the output file - 'data' or 'script'
• dir = source directory to create a tarball of
• dir_loc = location of the source file - 'data' or 'script' defaulting to data
• flags = may be an empty string or 'compress' which will cause the output .tar file to be bzip2 encoded.

tar_extract( file, file_loc, dir, dir_loc )

• file = the path and file name
• tar_location = source 'data' or 'script'
• dir = destination directory to extract the tar file to
• dir_location = destination 'data' or 'script'

time_t_dayofmonth( time_t, time_zone )

time_t_dayofyear( time_t, time_zone )

time_t_min( time_t, time_zone )

time_t_sec( time_t, time_zone )

tokenize( string, variables )

toupper( string )

wdownload( url, filepath, location, callback, callbackdata var )

• url = file to retrieve
• filepath = where destination file should be stored
• location = destination 'data' or 'script'.callback_fn = the name of a callback function in current Miva Script file
• callback_fn( size, total, data var ): a user defined user function that returns 1 to continue, 0 to abort.
• callbackdata var = opaque data that is passed as the data parameter to each call of callback_fn

x509_create( cert, x509 var )

x509_free( rsa var )

x509_get_issuer_name( certref var, issuername var )

• certref = Certificate reference returned from functions such as x509_load_mem
• issuername = Structure with members named for the entry names (e.g., "commonName", "countryName", etc.)

x509_load( cert, x509 var )

x509_pubkey_digest( x509 var, digestname, digest var )

• x509 = Certificate reference returned from functions such as x509_load_mem
• digestname = Hash algorithm name, such as "md5" or "sha256". Supported digest algorithms will vary between OpenSSL installations
• digest = Hash value of the public key of the certificate

x509_verify( x509 var, trusted_certs )

xml_parse_error( lineno var, error var )

• lineno = line number of the XML file the error occurred (if applicable)
• errortext = text of the error

xml_parse_section_getstate( target var )

• target = output aggregate

xml_parse_section_setstate( source var )

• source = input aggregate

xml_parse_var( var var, output var )

miva_joinstring( input var, join_with, flags )

• input = The input string, variable or simple array.
• join_with = The string that will seperate array elements
• flags = A comma separated list of any of the following keywords escape : Escapes the join_with characters. If the join_with characters exists in the elements value. insensitive : When combined with the escape flag, it will search for the join_with characters in an insensitive fashion.

crypto_next_error()

• Parameters: None

crypto_evp_sign( digestname, privkey, buffer, signature var )

• digestname = Hash algorithm name, such as "md5" or "sha256". Supported digest algorithms will vary between OpenSSL installations
• privkey = EVP PKEY structure reference
• buffer = The data to sign
• signature = The signed output signature

evp_pkey_load_pubkey_x509( x509 var, pkey var )

• x509 = Certificate reference returned from functions such as x509_load_mem
• pkey = Structure reference

redis_disconnect( conn_id )

• conn_id = The internal reference ID

redis_append( conn_id, key, value )

redis_bgsave( conn_id )

redis_bitfield( conn_id, key, options var, output var )

redis_bitpos( conn_id, key, bit, options var )

redis_brpop( conn_id, key, timeout, output var )

redis_client_getname( conn_id )

redis_client_list( conn_id )

redis_client_setname( conn_id, name )

redis_command_count( conn_id )

redis_command_info( conn_id, command_name, output var )

redis_config_resetstat( conn_id )

redis_config_set( conn_id, parameter, value )

redis_debug_object( conn_id, key )

redis_decr( conn_id, key )

redis_del( conn_id, key )

redis_dump( conn_id, key )

redis_eval( conn_id, script, key, arg )

redis_evalsha( conn_id, sha1, key, arg )

redis_exec( conn_id, output var )

redis_expire( conn_id, key, seconds )

redis_flushall( conn_id )

redis_geoadd( conn_id, key, longitude, latitude, member )

redis_geohash( conn_id, key, member, output var )

redis_georadius( conn_id, key, longitude, latitude, radius, unit, options var, output var )

redis_georadiusbymemberstore( conn_id, key, member, latitude, radius, unit, store_key )

redis_georadiusstore( conn_id, key, longitude, latitude, radius, unit, store_key, count )

redis_get( conn_id, key )

redis_getrange( conn_id, key, start, end )

redis_hdel( conn_id, key, field )

redis_hget( conn_id, key, field )

redis_hincrby( conn_id, key, field, increment )

redis_hkeys( conn_id, key, output var )

redis_hmget( conn_id, key, field, output var )

redis_hscan( conn_id, key, cursor, options var, output var )

redis_hsetnx( conn_id, key, field, value )

redis_hvals( conn_id, key, output var )

redis_incrby( conn_id, key, increment )

redis_info( conn_id )

redis_keys( conn_id, pattern, output var )

redis_lindex( conn_id, key, index )

redis_linsert_before( conn_id, key, pivot, value )

redis_lpop( conn_id, key )

redis_lpushx( conn_id, key, value )

redis_lrem( conn_id, key, count, value )

redis_ltrim( conn_id, key, start, stop )

redis_migrate( conn_id, host, port, key, destination_db, timeout, options var )

redis_mset( conn_id, key, value )

redis_multi( conn_id )

redis_object_idletime( conn_id, key )

redis_persist( conn_id, key )

redis_pexpireat( conn_id, key, milliseconds_timestamp )

redis_pfcount( conn_id, key )

redis_ping( conn_id )

redis_pttl( conn_id, key )

redis_randomkey( conn_id )

redis_renamenx( conn_id, key, newkey )

redis_role( conn_id, output var )

redis_rpoplpush( conn_id, source, destination )

redis_rpushx( conn_id, key, value )

redis_save( conn_id )

redis_scard( conn_id, key )

redis_script_flush( conn_id )

redis_script_load( conn_id, script )

redis_sdiffstore( conn_id, destination, key )

redis_set( conn_id, key, value, options var )

redis_setrange( conn_id, key, offset, value )

redis_shutdown_nosave( conn_id )

redis_sinter( conn_id, key, output var )

redis_sismember( conn_id, key, member )

redis_slowlog_get_count( conn_id, count, output var )

redis_slowlog_reset( conn_id )

redis_smove( conn_id, source, destination, member )

redis_sortstore( conn_id, key, destination, options var )

redis_spop_count( conn_id, key, count, output var )

redis_srandmember_count( conn_id, key, count, output var )

redis_sscan( conn_id, key, cursor, options var, output var )

redis_sunion( conn_id, key, output var )

redis_time( conn_id, output var )

redis_ttl( conn_id, key )

redis_unwatch( conn_id )

redis_zadd( conn_id, key, score, member, options var )

redis_zcount( conn_id, key, min, max )

redis_zinterstore( conn_id, destination, key, options var )

redis_zrange( conn_id, key, start, stop, options var, output var )

redis_zrangebyscore( conn_id, key, min, max, options var, output var )

redis_zrem( conn_id, key, member )

redis_zremrangebyrank( conn_id, key, start, stop )

redis_zrevrange( conn_id, key, start, stop, options var, output var )

redis_zrevrangebyscore( conn_id, key, max, min, optoins var, output var )

redis_zscan( conn_id, key, cursor, options var, output var )

redis_zunionstore( conn_id, destination, key, options var )