pike.git / CHANGES

version» Context lines:

pike.git/CHANGES:1: - (to browse bug crunch tickets noted at the end of these notes, either - visit http://community.roxen.com/crunch/ - or append the ticket id to - "http://bugs.roxen.com/" for a address directly to the ticket itself) + Pike 8: Changes since Pike 7.8 (scratch area for future release notes) + ----------------------------------------------------------------------    -  + New language features + ---------------------    - Changes since xxxx-yy-zz / Pike u.v.w (released ): - ---------------------------------------------------------------------- + o Added a way to access the local, and not the overloaded, +  implementation of a symbol.    -  +  As an example, given the classes: +  | class Test +  | { +  | int a( ) { return 1; } +  | int b( ) { return local::a(); } // New +  | int c( ) { return a(); } +  | } +  | +  | class Test2 +  | { +  | int a() { return 42; } +  | }    -  +  Both Test()->b() and Test2()->b() will return 1, but Test2()->a() +  and Test2()->c() will return 42.    - Changes since before then; Pike 7.2 - ---------------------------------------------------------------------- +     - New modules / classes / methods added: - -------------------------------------- + o Added new syntax that can be used to return the current object as if +  it was a class it is inheriting    - Compatibility changes: - ---------------------- +  The syntax is X::this, where X is the inherited class.    - Optimizations: +  The returned object will not include any symbols not available in +  the class X, but your overloaded methods (and other identifiers) +  will be the ones returned when the object is indexed. +  + o Added a way to easily inherit the implementation of a subclass in an +  inheriting class. +  +  | inherit ::this_program +  +  The syntax refers to the previous definition of the current class +  in the inherited class, and is typically used with inherit like: +  +  | inherit Foo; +  | +  | // Override the Bar inherited from Foo. +  | class Bar { +  | // The new Bar is based on the implementation of Bar in Foo. +  | inherit ::this_program; +  | // ... +  | } +  + o Added new syntax for referring to and naming inherits. +  +  | inherit "foo.pike"; +  | inherit "foo/bar/baz.pike" : "foo/bar"; +  | // ... +  | "foo.pike"::foo(); +  | "foo/bar"::baz(); +  + o Lookup of named inherits now also looks in indirect inherits. +  +  | class A { int fun() {} } +  | class B { inherit A; } +  | class C { +  | inherit B; +  | // ... +  | // The function fun may here be referred to as any of: +  | B::A::fun(); +  | B::fun(); +  | A::fun(); // New. +  + o Implemented the variant keyword. +  +  The keyword was present before, but did not actually do anything +  useful. +  +  This is used to do function overloading based on the argument types. +  +  As an example: +  | class Test1 { int b(); } +  | class Test2 { int a(); } +  | +  | class Foo +  | { +  | variant string foo( object q ){ return "Genericfoo"; } +  | variant string foo( Test1 x ) { return "Test 1"; } +  | variant string foo( Test2 x ) { return "Test 2"; } +  | +  | variant string bar( int(0..0) s ) { return "0"; } +  | variant float bar( int(1..1) s ) { return 1.0; } +  | variant int bar( int(2..2) s ) { return 2; } +  | } +  +  A common use-case is functions that return different types depending +  on the arguments, such as getenv: +  +  | string|mapping(string:string) getenv( string|void variable ); +  +  can now be rewritten as +  +  | variant string getenv( string variable ); +  | variant mapping(string:string) getenv( ); +  +  which gives significantly better type-checking. +  + o The type-checker has been rewritten. +  +  Mainly it is now much better at finding type errors, and most error +  messages are more readable. +  + o Allow '.' to be used as an index operator in the few places it did +  not work before. +  + o "Safe" index +  +  Copied from a popular extension to other C-like languages. +  +  X[?ind] is equivalent to ((auto _ = X),(_ && _[ind])) +  while X?->ind is equivalent to ((auto _ = X),(_ && _->ind)) +  +  The main use is 'deep indexing' where some elements can be 0: +  +  | request_id?->user?->misc?->x +  +  vs +  +  | request_id && request_id->user && request_id->user->misc +  | && request_id->user->misc->x +  + o Added the '?:' operator for compatibility with other C-like +  languages. It is identical to '||' in pike. +  + o The && operator changed, when doing A && B, and A is false, keep A +  instead of returning 0. +  +  This is especially useful then A is not actually 0, but an object +  that evaluates to false, or UNDEFINED. +  + o Fixed symbol resolution with deep inherits and mixins. +  + o Added multi-character character constants. +  +  'ILBM' is equivalent to (('I'<<24)|('L'<<16)|('B'<<8)|'M'). +  +  Unlike how it works in some C compilers the native byte order is +  never relevant. +  +  + New preprocessor features + ------------------------- +  + o Support for the ", ##__VA_ARGS__" cpp feature. +  +  This makes the ‘##’ token paste operator have a special meaning +  when placed between a comma and a variable argument. If you write +  +  | #define err(format, ...) f(debug)werror("ERROR: "+format, ##__VA_ARGS__) +  +  and the variable argument is left out when the err macro is used, +  then the comma before the ‘##’ will be deleted. This does not +  happen if you pass an empty argument, nor does it happen if the +  token preceding ‘##’ is anything other than a comma. +  + o The preprocessor can now be run with a cpp prefix feature. +  +  This is currently used by the precompiler to avoid two levels of +  preprocessing, one using "#cmod_" as the prefix and the other "#". +  + o Dynamic macros +  +  You can now add programatic macros. There is currently no syntax +  that can be used to define these while compiling code, but you can +  add them from one program before compiling plug-ins/modules. +  +  The main use is macros like DEBUG(...) and IFDEBUG() that would +  expand to something if a debug setting is enabled in the module but +  nothing otherwise, or, to take an actual example from the Opera +  Mini source code: +  +  | add_predefine( "METRIC()", +  | lambda( string name, string ... code ) +  | { +  | string type = type_of( code ); +  | string aggregate = aggregate_of( code ); +  | string format = format_of( code ); +  | code -= ({ 0 }); +  | return replace( base_metric_class, +  | (["ID":(string)next_metric_id++, +  | "NAME":stringify(name), +  | "TYPE":type, +  | "AGGREGATE":aggregate, +  | "FORMAT":format, +  | "CODE":make_value_function(code), +  | ])); +  | }); +  +  +  That is, a macro that needs does some calculations, and rewrite the +  code more than is possible in normal macros.. +  +  This one expands something along the lines of +  +  | METRIC("requests", Summarize, PerSecond, +  | floating_average_diff(requests)); +  +  into +  +  | class Metric_requests_01 +  | { +  | inherit Server.Metric; +  | constant name = "transcoder:requests"; +  | constant type = Float; +  | constant format = PerSecond; +  | constant aggregate = Summarize; +  | +  | float value() { +  | return floating_average_diff(requests); +  | } +  | } +  + o Dependency declarations +  +  It is now possible to use the CPP directive #require to specify a +  condition that must be true for the file to be seen by the resolver. +  This would typically be the inherited C part of a module or a system +  call. +  +  | #require constant(__WebKit) +  | inherit __WebKit; +  +  + Optimizations + ------------- +  + o New significantly faster block allocator +  +  The free in the old one was O(n^2), which means that as an example +  creating a lot of objects and then free:ing them mainly used CPU in +  the block allocator. +  +  This fix changed the ordo of one of the tests that did that very +  thing (binarytrees) from O(n^2) to O(n), and as such is more than a +  simple percentual speedup in some cases, but it always improves the +  performance some since the base speed is also faster. +  + o Power-of-two hashtables are now used for most hashtables +  +  This speeds up mappings and other hashtables a few percent, and also +  simplifies the code. +  + o Significantly changed x86-32 and an entirely new AMD64/x86-64 +  machine-code compilation backend +  +  The main feature with the x86-32 edition is that it is now using +  normal function call mechanics, which means that it now works with +  modern GCC:s. +  +  The x86-64 backends has been rewritten so that it is easier to add +  new instructions (x86-64) and opcodes (pike) to it. +  + o Svalue type renumbering +  +  PIKE_T_INT is now type #0, which makes certain things significantly +  faster. +  +  As an example, clearing of object variables is now done +  automatically when the object is created since all object memory is +  set to 0. +  +  The same thing happens when clearing values on the stack. +  + o string(x..y) (constant) types +  +  The strings now keep track of the min/max values in addition to two +  new flags: all-uppercase and all-lowercase. +  +  | > typeof("foo"); +  | (1) Result: string(102..111) +  +  This is used to optimize certain operations, +  lower_case, upper_case, search and string_has_null for now. +  It could be added to other places in the future as well. +  +  The fairly common case where you are doing lower_case or upper_case +  on an already lower or uppercase strings is now significantly +  faster. +  + o Several other optimizations to execution speed has been done +  +  + object indexing (cache, generic speedups) +  +  + lower_apply, changes to apply in general +  Taken together these individually small optimizations speeds up at +  least pike -x benchmark more than 5%. +  +  + A lot of opcodes implemented in machine-code for x86-64 +  This speed up the loop benchmarks close to a factor of 3. But then +  again, most real code is nothing like that benchmark. +  +  + Several new opcodes added +  As an example an observation was that most branch_if_zero is +  followed by an is_eq, is_lt or is_gt or similar. Those opcodes +  always return 1 or 0. So, two new opcodes, quick_branch_if_zero +  and quick_branch_if_non_zero were added that map directly to three +  x86-64 opcodes, there is no need to check the types, do a real +  pop_stack etc. +  + o Faster hash-function for strings +  +  + Also siphash24 was added and is used in case the string hash table +  becomes inefficient +  +  + Deprecated features and modules + ------------------------------- +  + o Tools.PEM and Tools.X409 deprecated +  +  Use the corresponding modules in Standards. +  + o The built in sandbox is now deprecated +  +  Unless somebody wants to take ownership of the feature and keep it +  up to date the security system will be removed in the next stable +  release. +  + o The compiler now warns about switch statements where the cases +  aren't enumerable, since these will generate random failures +  if the code is read from a dump. +  + o strlen() now only accepts strings +  +  + Removed features and modules + ---------------------------- +  + o Removed facets +  +  The optional (and not enabled by default) support for facet classes +  has been removed, since it was only partially done and not really +  used. +  + o It is no longer possible to compile pike without libgmp. +  +  Bignums are now a required language feature +  + o The old low-level 'files' module has been renamed to _Stdio +  + o 'GTK' is now GTK2, not GTK1 unless the system has no GTK2 support. +  + o Locale.Charset +  +  The charset module is now available on the top level as 'Charset' +  +  + New modules + ----------- +  + o Pike.Watchdog +  +  A Watchdog that ensures that the process is not hung for an extended +  period of time. The definition of 'hung' is: Has not used the +  default backend. +  +  To use it simply keep an instance of the watchdog around in your +  application: +  +  | Pike.Watchdog x = Pike.Watchdog( 5 ); // max 5s blocking +  +  An important and useful side-effect of this class is that the +  process will start to respond to kill -QUIT by printing a lot of +  debug information to stderr, including memory usage, and if pike is +  compiled with profiling, the CPU used since the last time kill -QUIT +  was called. +  + o Crypto.Password +  +  A module that can be used to verify and create passwd/ldap style +  password hashes. +  +  It tries to support most common password hashing schemes. +  + o Debug.Profiling +  +  Tools useful for collecting and format for output the profiling +  information generated when pike is compiled --with-profiling. +  + o NetUtils +  +  This module contains a lot of functions useful for the storage and +  processing of network addresses, it supports IPv4 and IPv6. +  + o Added ADT.CritBit module +  +  Mapping-like key-sorted data structures for string, int and +  float-keys (ADT.CritBit.Tree, ADT.CritBit.IntTree, +  ADT.CritBit.FloatTree). Implemented in C. +  + o Standards.BSON +  +  A new module for working with BSON serialized data. +  See http://bsonspec.org/ +  + o Geography.GeoIP +  +  Does geolocation of IPv4-numbers using databases from maxmind.com +  or software77.net +  + o Protocols.WebSocket +  +  An implementation of the WebSocket (RFC 6455) standard, both server +  and client +  + o Image.WebP +  +  Encoder and decoder for the WEBP image format. +  More information about the format can be found on +  https://developers.google.com/speed/webp/ +  + o Serializer +  +  APIs useful to simplify serialization and deserialization of +  objects Mainly it allows you to easily iterate over the object +  variables, including the private ones. +  +  + Serializer.Encodable +  A class that can be inherit to make an object easily serializable +  using encode_value. +  + o Filesystem.Monitor and the low level System.Inotify + System.FSEvents +  +  Basic filesystem monitoring. +  +  This module is intended to be used for incremental scanning of a +  filesystem. +  +  Supports FSEvents on MacOS X and Inotify on Linux to provide low +  overhead monitoring; other systems currently use a less efficient +  polling approach. +  + o Mysql.SqlTable +  +  This class provides some abstractions on top of an SQL table. +  +  At the core it is generic for any SQL database, but the current +  implementation is MySQL specific on some points, notably the +  semantics of AUTO_INCREMENT, the quoting method, knowledge about +  column types, and some conversion functions. Hence the location in +  the Mysql module. +  +  Among other things, this class handles some convenient conversions +  between SQL and pike data types +  + o Parser.CSV +  +  This is a parser for line oriented data that is either comma, +  semi-colon or tab separated. It extends the functionality +  of the Parser.Tabular with some specific functionality related +  to a header and record oriented parsing of huge datasets. +  + o ZXID +  +  ZXID is a library that implements SAML 2.0, Liberty ID-WSF 2.0 +  and XACML 2.0. +  +  This module implements a wrapper for ZXID. The interface is similar +  to the C one, but using generally accepted Pike syntax. +  + o Git +  +  A module for interacting with the Git distributed version control +  system. +  + o Val +  +  This module contains special values used by various modules, e.g. +  a Val.null value used both by Sql and Standards.JSON. +  +  In many ways these values should be considered constant, but it is +  possible for a program to replace them with extended versions, +  provided they don't break the behavior of the base classes defined +  here. Since there is no good mechanism to handle such extending in +  several steps, pike libraries should preferably ensure that the +  base classes defined here provide required functionality directly. +  + o __builtin +  +  The __builtin module is now a directory module, so that it can provide +  a suitable namespace for code written in Pike intended for being +  inherited from modules written in C (cf precompile). +  +  + Extensions and new functions + ---------------------------- +  + o Bz2.File added +  +  It implements a Stdio.File like API, including support for the same +  iterator API that Stdio.File has, allowing for convenient line +  iterations over BZ2 compressed files. +  +  | foreach( Bz2.File("log.bz2")->line_iterator(); int n; string line ) +  + o Image.JPEG +  +  + decode now supports basic CMYK/YCCK support +  +  + exif_decode is a new function that will rotate the image +  according to exif information +  + o String.Buffer +  +  String.Buffer can now add the storage from a different String.Buffer +  object with the add() method. +  +  It is possible to add sprintf-formatted data to a String.Buffer +  object by calling the sprintf() method. This function works just as +  the normal sprintf(), but writes to the buffer instead. +  +  The new method addat() allows for writing into the buffer at any +  position. +  + o SDL.Music added to SDL. +  +  Allows the playback of audio/music files. +  Requires the SDL_mixed library. +  + o System.TM +  +  Low-level wrapper for struct tm. +  +  This can be used to do (very) simple calendar operations. It is, +  as it stands, not 100% correct unless the local time is set to +  GMT, and does mirror functionality already available in gmtime() +  and localtime() and friends, but in a (perhaps) easier to use API. +  + o decode_value now throws the error object Error.DecodeError. +  +  Useful to catch format errors in the decode string. +  + o Process.daemon +  +  The daemon() function is for programs wishing to detach themselves +  from the controlling terminal and run in the background as system +  daemons. +  + o Debug.pp_object_usage() +  +  Pretty-print debug information, useful to get debug information +  about object counts and memory usage in pike applications. +  +  Uses the new _object_size lfun, if present in objects, to account +  for RAM-usage in C-objects that allocate their own memory. +  + o Mysql +  +  + Added support more modern client libraries (incl. MariaDB) +  +  + Mysql.mysql now has methods to query the id or SQLSTATE of the +  last error. +  + o Protocols.DNS +  +  + Prevent endless loops in maliciously crafted domain names. +  +  + Add QTYPE T_ANY to DNS enum EntryType in DNS.pmod. +  +  + Handle truncated labels +  +  + TCP client and server support +  + o Thread no longer inherits Thread.Thread (aka thread_create) +  + o Thread.Farm now might work +  + o Cmod precompiler. +  +  + inherit "identifier" +  -- inherit the program returned by calling master()->resolve() on +  the specified identifier. Useful to inherit code written in pike. +  + o String.levenshtein_distance() +  +  The function calculates the Levenshtein distance between two +  strings. The Levenshtein distance describes the minimum number of +  edit operations (insert, delete or substitute a character) to get +  from one string to the other. +  +  This can be used in approximate string matching to find matches +  for a short string in many longer texts, when a small number of +  differences is expected. +  + o System.sync() +  +  Synchronizes the filesystem on systems where this is possible +  (currently windows and UNIX-like systems). +  + o System.getloadavg() +  +  Return the current 1, 5 and 15 minute system load averages as an array. +  + o access() +  +  Check if a file exist and can also return if it is readable and or +  writeable for the current process. +  + o glob() +  +  The glob function has been extended to accept an array of globs as +  the first (glob pattern) argument. +  +  In this case, if any of the given patterns match the function will +  return true, or, if the second argument is also an array, all +  entries that match any glob in the first array. +  + o Stdio.UDP(): +  +  + added IPv6 multicast support +  +  + added set_buffer +  + o Stdio.File(): +  +  + send_fd and receive_fd +  These functions can be used to send and receive an open +  file-descriptor over another file-descriptor. The functions are +  only available on some systems, and they generally only work +  when the file the descriptors are sent over is a UNIX domain +  socket or a pipe. +  +  + Changed internally to remove one level of indirection. +  The Stdio.File object no longer has a _Stdio.Fd_ref in _fd. They +  are instead directly inheriting _Stdio.FD. +  +  _fd is still available for compatibility, but internally it is gone. +  +  + Fixed grantpt() on Solaris failing with EPERM. +  + o Unicode databases updated to 6.3.0 from 5.1.0 +  +  This is the latest released Unicode database from unicode.org. +  + o The Search search engine module has seen several fixes +  +  + Added support for padded blobs. This improves performance when +  incrementally growing blobs. This feature is only enabled if +  Search.Process.Compactor says this is OK, see the documentation +  for more information. +  +  + Several locking optimizations, specifically, avoid locking and +  unlocking for every single iteration when merging and syncing +  blobs. +  +  + Charset conversion fixes +  +  + Fixes for queries where the same world occur multiple times +  ('foo and bar and foo') +  + o pike -x benchmark +  +  + Output format changed +  +  + Also added support for JSON output. +  +  + The results should be more consistent. +  +  + Added options to allow comparison with a previous run. +  + o New stand-alone tools added to make it possible to build +  documentation without the pike build tree +  +  + autodoc_to_html +  AutoDoc XML to HTML converter. +  +  + autodoc_to_split_html +  AutoDoc XML to splitted HTML converter. +  +  + git_export_autodoc +  Exports a stream of autodoc.xml suitable for git-fast-import. +  Used on pike-librarian. +  + o Readline tries to set the charset to the terminal charset +  +  This makes it possible to write non-7bit characters on a terminal +  if the terminal supports it. +  + o Fixed units in pike --help=kladdkaka +  + o Several changes has been done to the GTK2 module +  +  + GTK2.DrawingArea no longer crash in draw_text if you pass odd parameters. +  +  + draw_pixbuf can now be passed width and height -1, which makes it +  take the size from the passed image. +  +  + GDKEvent no longer crash when you extract strings from them +  +  + accelerators now work +  +  + Fixed RadioToolButton +  +  + signal_connect can now connect a signal in front of the list +  +  + Several fixes to Tree related objects +  +  + GTK2.SourceView added +  +  + GTK2.Spinner added +  + o A few issues were fixed that were found by Coverity +  +  + Fixed memory leak in Math.Transform +  +  + Fixed two compares that were written as assignments (errno +  checks for EINTR for sockets) +  + o System.get_home + System.get_user +  +  (mostly) Cross-platform ways to get the user name and home directory. +  + o System.AllocConsole, System.FreeConsole and System.AttachConsole for NT +  +  These are useful to create or close the console window that is +  shown for pike programs. +  + o Process - forkd +  +  Forkd can be used to more cheaply create new processes on UNIX like +  systems. +  +  This is done by first starting a sub-process that is then used to +  create new processes. +  +  If your main process is large, this is significantly faster than +  using the normal create_process, and does not risk running out of +  memory for the forked (temporary) copy of the main process that is +  created. +  + o MacOSX CoreFoundation support in the backend +  +  This makes it somewhat more likely that native libraries can work +  with pike. +  + o Better IPv6 support. +  +  This includes detection of IPV6 mapped IPV4 addresses +  (::FFFF:i.p.v.4) and full support for IPv6 in the UDP +  code. +  + o Asynchronous Protocols.SNMP client +  + o Fixes to Process.run, Process.spawn_pike and friends. +  +  + Support OS/2 path conventions +  +  + Fixed multiple issues with search_path()/locate_binary() +  - locate_binary() is now more reliable on Windows +  - Now invalidates the cached path is PATH is changed +  - Uses locate_binary to scan the path +  - spawn_pike() now uses search_path() +  +  + You can now optionally have System.spawn_pike pass predefines, +  program and include path to the spawned pike, in addition to the +  module path. +  + o Lots of autodoc fixes +  +  A lot more of the previously existing, but broken, documentation is +  now readable. +  + o predef::types +  +  This is equivalent to values and indices, but instead gives the +  types for each value. +  +  Basically only useful for objects. +  + o Builtin._get_setter +  +  This function returns a setter for a variable in an object. +  The setter, when called, will set the variable value to the passed +  argument. +  + o Parser.XML.Tree fixes +  +  + Several namespace improvement and handling fixes +  + o New charsets +  +  A lot of ISO-IR charsets added: +  9-1, 9-2, 31, 232, 234, 231 (aka ANSI/NISO Z39.46, aka ANSEL) 230 +  (aka TDS 565) 225 (SR 14111:1998), 197/209 (sami) 208 (IS 434:1997) +  207 (IS 433:1996), 204,205 and 206 (aka 8859-1, 8859-4 and 8859-13 +  with euro) 201, 200, 138 (ECMA-121) 198 (ISO 8859-8:1999) 182, 181, +  189 (TCVN 5712:1993, aka VSCII) 167, 166 (aka TIS 620-2533 (1990)), +  164, 160, 151 (NC 99-10:81), 68 (APL), 59 (CODAR-U), 202 (KPS +  9566-97). Fixed CSA_Z242.4 +  + o Several fixes to Protocols.HTTP +  +  + Improved Protocols.HTTP.Query.PseudoFile +  (significantly better Stdio.Stream simulation) +  +  + Do not use hard coded Linux errno:s +  +  + Case insensitive handling of header overrides in do_method +  +  + Fixed broken check for URL passwords when querying +  +  + Add more descriptive HTTP responses along with a mostly complete +  list of codes +  +  + Handle non-standards compliant relative redirects +  +  + Cleaner handling of async DNS failures +  +  + Handle chunked transfer encoding correctly when doing async +  queries +  +  + Fixes for the proxy client support +  +  + Several keep-alive handling fixes +  +  + Server: +  - More forgiving MIME parsing for MSIE +  - Fixed range header handling +  - Fixed parsing of broken multipart/form-data data +  - Added optional error_callback to attach_fd +  - The response processor (response_and_finish) now treats the +  reply mapping as read-only. +  - Support if-none-match (etag:s) +  - Ignore errors in close when destroying the object +  + o dtrace support (on MacOSX) +  +  Pike now supports dtrace events on function enter and leaving (and +  when stack frames are notionally popped, for functions doing +  tailrecursion). +  + o sizeof() now supports ADT.struct. +  +  + Crypto and SSL   --------------    - Improvement and bug tickets closed: 1499 + o SNI client extension support for SSL (Server Name Indicator) +  + o Standards.PEM +  +  + Added some support for encrypted PEM files +  + o Nettle refactored +  +  CBC cipher mode is now twice as fast. +  + o Crypto.GCM +  +  GCM (Galois Counter Mode) cipher mode added. +  + o AES support added to the SSL module +  +  This adds support for the following cipher suites: +  TLS_rsa_with_aes_128_cbc_sha +  TLS_dhe_dss_with_aes_128_cbc_sha +  TLS_dhe_rsa_with_aes_128_cbc_sha +  TLS_rsa_with_aes_256_cbc_sha +  TLS_dhe_dss_with_aes_256_cbc_sha +  TLS_dhe_rsa_with_aes_256_cbc_sha +  + o SSL now supports TLS 1.0 (SSL 3.1) and TLS 1.1 +  + o Blowfish and Serpent support fixed in Nettle +  + o Crypto.PGP +  +  Added support for SHA256, SHA384 and SHA512 as hash functions. +  Expose the used hash and key types in the out data +  + o Crypto.Arctwo +  +  The 1-128 bit cipher Arctwo is now provided as a block cipher in +  Crypto. This cipher is only intended for compatibility with OLD +  third party code, and should NOT be used for new development. +  + o Crypto.Camellia +  +  The 128/256 bit cipher Camellia is now available as block cipher in +  Crypto. In addition the following cipher suites have been added to +  SSL: +  +  TLS_rsa_with_camellia_128_cbc_sha +  TLS_dhe_dss_with_camellia_128_cbc_sha +  TLS_dhe_rsa_with_camellia_128_cbc_sha +  TLS_rsa_with_camellia_256_cbc_sha +  TLS_dhe_dss_with_camellia_256_cbc_sha +  TLS_dhe_rsa_with_camellia_256_cbc_sha +  + o Crypto.SALSA20 and Crypto.SALSA20R12 +  +  The 128/256 bit cipher SALSA20 is now available as a stream cipher +  in Crypto. SALSA20R12 is SALSA20 reduced to just 12 rounds. +  + o Crypto.SHA3_224, Crypto.SHA3_256, Crypto.SHA3_384 and Crypto.SHA3_512 +  +  The SHA-3 secure hash algorithm has been added in multiple variants. +  + o Crypto.GOST94 and RIPEMD160 +  +  The lesser used hash functions GOST R 34.11-94 (RFC 4357) and +  RIPEMD160 have been added. +  + o Crypto.RSA and Crypto.DSA +  +  The key generation for RSA and DSA are now done by Nettle. This +  results in 90% faster key generation for RSA. Key generation for DSA +  is 10 times slower, but produces better quality keys. +  + o Crypto.Hash +  +  Added support for pbkdf1 from PKCS#5v1.5 and pbkdf2 from PKCS#5v2.0. +  + o Standards.X509 +  +  X509 was moved from Tools to Standards and has been refactored and +  bug fixed. It is now possible to extend both validation and creation +  of certificates with new cipher and hash algorithms. A range of new +  algorithms are supported for both RSA and DSA: +  +  RSA MD2 +  RSA MD5 +  RSA SHA-1 +  RSA SHA-2-256 +  RSA SHA-2-384 +  RSA SHA-2-512 +  DSA SHA-1 +  DSA SHA-2-224 +  DSA SHA-2-256 +  +  Note that the API has changed compared with Tools.X509 and there is +  now a single make_selfsigned_certificate() method for both RSA and +  DSA, though it takes the same arguments. In addition a hash function +  and serial number can be supplied. The hash function defaults to +  SHA-2-256. +  +  + Building and installing + ----------------------- +  + o -fvisibility=hidden is now the default +  +  This means that PMOD_EXPORT is now actually needed on systems like +  Linux and MacOSX. It also means that the binary is slightly smaller +  and faster. +  + o clang compilation fixes (bignum overflow checks, misc) +  +  It is now possible to compile pike using a modern clang compiler. +  + o Removed bundles +  +  Pike no longer comes with copies of some libraries, and the support +  for that in the makefile has been removed. +  + o Several OS/2 and windows compilation fixes +  +  + Lots of bug fixes + ----------------- +  +  + o Fixed symbol resolution with deep inherits and mixins +  + o Fixed PNG 4bpl indexed mode with alpha +  + o The _sprintf LFUN now works with %F +  + o A lot more, see the (more or less) full changelog for more info: +  +  http://pike-librarian.lysator.liu.se/index.xml?m=pike.git&start=forever&branch=7.9&template=logonly.inc