yetangitu/deltachat-core
1
0
Fork 0
mirror of https://github.com/deltachat/deltachat-core.git synced 2025-10-03 09:49:15 +02:00
Code Issues Releases Wiki Activity
deltachat-core/cmdline/stress.c
B. Petersen 77a714a1d3
add utf8-len function
2019-04-16 18:36:30 +02:00

1099 lines
44 KiB
C
Raw Permalink Blame History

/* Stress some functions for testing; if used as a lib, this file is obsolete.
For memory checking, use eg.
$ valgrind --leak-check=full --tool=memcheck ./deltachat-core <db>
*/
#include <ctype.h>
#include <assert.h>
#include "../src/dc_context.h"
#include "../src/dc_simplify.h"
#include "../src/dc_mimeparser.h"
#include "../src/dc_mimefactory.h"
#include "../src/dc_pgp.h"
#include "../src/dc_apeerstate.h"
#include "../src/dc_aheader.h"
#include "../src/dc_keyring.h"
#include "../src/dc_saxparser.h"
/* some data used for testing
******************************************************************************/
/* s_em_setupfile is a AES-256 symm. encrypted setup message created by Enigmail
with an "encrypted session key", see RFC 4880. The code is in s_em_setupcode */
static const char* s_em_setupcode = "1742-0185-6197-1303-7016-8412-3581-4441-0597";
static const char* s_em_setupfile =
"-----BEGIN PGP MESSAGE-----\n"
"Passphrase-Format: numeric9x4\n"
"Passphrase-Begin: 17\n"
"\n"
"wy4ECQMI0jNRBQfVKHVg1+a2Yihd6JAjR9H0kk3oDVeX7nc4Oi+IjEtonUJt\n"
"PQpO0tPWASWYuYvjZSuTz9r1yZYV+y4mu9bu9NEQoRlWg2wnbjoUoKk4emFF\n"
"FweUj84iI6VWTCSRyMu5d5JS1RfOdX4CG/muLAegyIHezqYOEC0Z3b9Ci9rd\n"
"DiSgqqN+/LDkUR/vr7L2CSLN5suBP9Hsz75AtaV8DJ2DYDywYX89yH1CfL1O\n"
"WohyrJPdmGJZfdvQX0LI9mzN7MH0W6vUJeCaUpujc+UkLiOM6TDB74rmYF+V\n"
"Z7K9BXbaN4V6dyxVZfgpXUoZlaNpvqPJXuLHJ68umkuIgIyQvzmMj3mFgZ8s\n"
"akCt6Cf3o5O9n2PJvX89vuNnDGJrO5booEqGaBJfwUk0Rwb0gWsm5U0gceUz\n"
"dce8KZK15CzX+bNv5OC+8jjjBw7mBHVt+2q8LI+G9fEy9NIREkp5/v2ZRN0G\n"
"R6lpZwW+8TkMvJnriQeABqDpxsJVT6ENYAhkPG3AZCr/whGBU3EbDzPexXkz\n"
"qt8Pdu5DrazLSFtjpjkekrjCh43vHjGl8IOiWxKQx0VfBkHJ7O9CsHmb0r1o\n"
"F++fMh0bH1/aewmlg5wd0ixwZoP1o79he8Q4kfATZAjvB1xSLyMma+jxW5uu\n"
"U3wYUOsUmYmzo46/QzizFCUpaTJ4ZQZY1/4sflidsl/XgZ0fD1NCrdkWBNA1\n"
"0tQF949pEAeA4hSfHfQDNKAY8A7fk8lZblqWPkyu/0x8eV537QOhs89ZvhSB\n"
"V87KEAwxWt60+Eolf8PvvkvB/AKlfWq4MYShgyldwwCfkED3rv2mvTsdqfvW\n"
"WvqZNo4eRkJrnv9Be3LaXoFyY6a3z+ObBIkKI+u5azGJYge97O4E2DrUEKdQ\n"
"cScq5upzXity0E+Yhm964jzBzxnA52S4RoXzkjTxH+AHjQ5+MHQxmRfMd2ly\n"
"7skM106weVOR0JgOdkvfiOFDTHZLIVCzVyYVlOUJYYwPhmM1426zbegHNkaM\n"
"M2WgvjMp5G+X9qfDWKecntQJTziyDFZKfd1UrUCPHrvl1Ac9cuqgcCXLtdUS\n"
"jI+e1Y9fXvgyvHiMX0ztSz1yfvnRt34508G9j68fEQFQR/VIepULB5/SqKbq\n"
"p2flgJL48kY32hEw2GRPri64Tv3vMPIWa//zvQDhQPmcd3S4TqnTIIKUoTAO\n"
"NUo6GS9UAX12fdSFPZINcAkNIaB69+iwGyuJE4FLHKVkqNnNmDwF3fl0Oczo\n"
"hbboWzA3GlpR2Ri6kfe0SocfGR0CHT5ZmqI6es8hWx+RN8hpXcsRxGS0BMi2\n"
"mcJ7fPY+bKastnEeatP+b0XN/eaJAPZPZSF8PuPeQ0Uc735fylPrrgtWK9Gp\n"
"Wq0DPaWV/+O94OB/JvWT5wq7d/EEVbTck5FPl4gdv3HHpaaQ6/8G89wVMEXA\n"
"GUxB8WuvNeHAtQ7qXF7TkaZvUpF0rb1aV88uABOOPpsfAyWJo/PExCZacg8R\n"
"GOQYI6inV5HcGUw06yDSqArHZmONveqjbDBApenearcskv6Uz7q+Bp60GGSA\n"
"lvU3C3RyP/OUc1azOp72MIe0+JvP8S5DN9/Ltc/5ZyZHOjLoG+npIXnThYwV\n"
"0kkrlsi/7loCzvhcWOac1vrSaGVCfifkYf+LUFQFrFVbxKLOQ6vTsYZWM0yM\n"
"QsMMywW5A6CdROT5UB0UKRh/S1cwCwrN5UFTRt2UpDF3wSBAcChsHyy90RAL\n"
"Xd4+ZIyf29GIFuwwQyzGBWnXQ2ytU4kg/D5XSqJbJJTya386UuyQpnFjI19R\n"
"uuD0mvEfFvojCKDJDWguUNtWsHSg01NXDSrY26BhlOkMpUrzPfX5r0FQpgDS\n"
"zOdY9SIG+y9MKG+4nwmYnFM6V5NxVL+6XZ7BQTvlLIcIIu+BujVNWteDnWNZ\n"
"T1UukCGmFd8sNZpCc3wu4o/gLDQxih/545tWMf0dmeUfYhKcjSX9uucMRZHT\n"
"1N0FINw04fDdp2LccL+WCGatFGnkZVPw3asid4d1od9RG9DbNRBJEp/QeNhc\n"
"/peJCPLGYlA1NjTEq+MVB+DHdGNOuy//be3KhedBr6x4VVaDzL6jyHu/a7PR\n"
"BWRVtI1CIVDxyrEXucHdGQoEm7p+0G2zouOe/oxbPFoEYrjaI+0e/FN3u/Y3\n"
"aG0dlYWbxeHMqTh2F3lB/CFALReeGqqN6PwRyePWKaVctZYb6ydf9JVl6q1/\n"
"aV9C5rf9eFGqqA+OIx/+XuAG1w0rwlznvtajHzCoUeA4QfbmuOV/t5drWN2N\n"
"PCk2mJlcSmd7lx53rnOIgme1hggchjezc4TisL4PvSLxjJ7DxzktD2jv2I/Q\n"
"OlSxTUaXnGfIVedsI0WjFomz5w9tZjC0B5O5TpSRRz6gfpe/OC3kV7qs1YCS\n"
"lJTTxj1mTs6wqt0WjKkN/Ke0Cm5r7NQ79szDNlcC0AViEOQb3U1R88nNdiVx\n"
"ymKT5Dl+yM6acv53lNX6O5BH+mpP2/pCpi3x+kYFyr4cUsNgVVGlhmkPWctZ\n"
"trHvO7wcLrAsrLNqRxt1G3DLjQt9VY+w5qOPJv6s9qd5JBL/qtH5zqIXiXlM\n"
"IWI9LLwHFFXqjk/f6G4LyOeHB9AqccGQ4IztgzTKmYEmFWVIpTO4UN6+E7yQ\n"
"gtcYSIUEJo824ht5rL+ODqmCSAWsWIomEoTPvgn9QqO0YRwAEMpsFtE17klS\n"
"qjbYyV7Y5A0jpCvqbnGmZPqCgzjjN/p5VKSNjSdM0vdwBRgpXlyooXg/EGoJ\n"
"ZTZH8nLSuYMMu7AK8c7DKJ1AocTNYHRe9xFV8RzEiIm3zaezxa0r+Fo3nuTX\n"
"UR9DOH0EHaDLrFQcfS5y1iRxY9CHg0N2ECaUzr/H7jck9mLZ7v9xisj3QDuv\n"
"i0xQbC4BTxMEBGTK8fOcjHHOABOyhqotOreERqwOV2c1OOGUQE8QK18zJCUd\n"
"BTmQZ709ttASD7VWK4TraOGczZXkZsKdZko5T6+6EkFy9H+gwENLUG9zk0x9\n"
"2G5zicDr6PDoAGDuoB3B3VA8ertXTX7zEz30N6m+tcAtPWka0owokLy3f0o7\n"
"ZdytBPkly8foTMWKF2vsJ8K4Xdn/57jJ2qFku32xmtiPIoa6s8wINO06AVB0\n"
"0/AuttvxcPr+ycE+9wRZHx6JBujAqOZztU3zu8WZMaqVKb7gnmkWPiL+1XFp\n"
"2+mr0AghScIvjzTDEjigDtLydURJrW01wXjaR0ByBT4z8ZjaNmQAxIPOIRFC\n"
"bD0mviaoX61qgQLmSc6mzVlzzNZRCKtSvvGEK5NJ6CB6g2EeFau8+w0Zd+vv\n"
"/iv6Img3pUBgvpMaIsxRXvGZwmo2R0tztJt+CqHRvyTWjQL+CjIAWyoHEdVH\n"
"k7ne/q9zo3iIMsQUO7tVYtgURpRYc2OM1IVQtrgbmbYGEdOrhMjaWULg9C7o\n"
"6oDM0EFlCAId3P8ykXQNMluFKlf9il5nr19B/qf/wh6C7DFLOmnjTWDXrEiP\n"
"6wFEWTeUWLchGlbpiJFEu05MWPIRoRd3BHQvVpzLLgeBdxMVW7D6WCK+KJxI\n"
"W1rOKhhLVvKU3BrFgr12A4uQm+6w1j33Feh68Y0JB7GLDBBGe11QtLCD6kz5\n"
"RzFl+GbgiwpHi3nlCc5yiNwyPq/JRxU3GRb62YJcsSQBg+CD3Mk5FGiDcuvp\n"
"kZXOcTE2FAnUDigjEs+oH2qkhD4/5CiHkrfFJTzv+wqw+jwxPor2jkZH2akN\n"
"6PssXQYupXJE3NmcyaYT+b5E6qbkIyQj7CknkiqmrqrmxkOQxA+Ab2Vy9zrW\n"
"u0+Wvf+C+SebWTo3qfJZQ3KcASZHa5AGoSHetWzH2fNLIHfULXac/T++1DWE\n"
"nbeNvhXiFmAJ+BRsZj9p6RcnSamk4bjAbX1lg2G3Sq6MiA1fIRSMlSjuDLrQ\n"
"8xfVFrg7gfBIIQPErJWv2GdAsz76sLxuSXQLKYpFnozvMT7xRs84+iRNWWh9\n"
"SNibbEjlh0DcJlKw49Eis/bN22sDQWy4awHuRvvQetk/QCgp54epuqWnbxoE\n"
"XZDgGBBkMc3or+6Cxr3q9x7J/oHLvPb+Q5yVP9fyz6ZiSVWluMefA9smjJ/A\n"
"KMD84s7uO/8/4yug+swXGrcBjHSddTcy05vm+7X6o9IEZKZb5tz7VqAfEcuk\n"
"QNPUWCMudhzxSNr4+yVXRVpcjsjKtplJcXC5aIuJwq3C5OdysCGqXWjLuUu1\n"
"OFSoPvTsYC2VxYdFUcczeHEFTxXoXz3I0TyLPyxUNsJiKpUGt/SXmV/IyAx+\n"
"h6pZ2OUXspC9d78DdiHZtItPjEGiIb678ZyMxWPE59XQd/ad92mlPHU8InXD\n"
"yTq6otZ7LwAOLGbDR9bqN7oX8PCHRwuu30hk2b4+WkZn/WLd2KCPddQswZJg\n"
"Qgi5ajUaFhZvxF5YNTqIzzYVh7Y8fFMfzH9AO+SJqy+0ECX0GwtHHeVsXYNb\n"
"P/NO/ma4MI8301JyipPmdtzvvt9NOD/PJcnZH2KmDquARXMO/vKbn3rNUXog\n"
"pTFqqyNTr4L5FK86QPEoE4hDy9ItHGlEuiNVD+5suGVGUgYfV7AvZU46EeqO\n"
"rfFj8wNSX1aK/pIwWmh1EkygPSxomWRUANLX1jO6zX9wk2X80Xn9q/8jot1k\n"
"Vl54OOd7cvGls2wKkEZi5h3p6KKZHJ+WIDBQupeJbuma1GK8wAiwjDH59Y0X\n"
"wXHAk7XA+t4u0dgRpZbUUMqQmvEvfJaCr4qMlpuGdEYbbpIMUB1qCfYU9taL\n"
"zbepMIT+XYD5mTyytZhR+zrsfpt1EzbrhuabqPioySoIS/1+bWfxvndq16r0\n"
"AdNxR5LiVSVh8QJr3B/HJhVghgSVrrynniG3E94abNWL/GNxPS/dTHSf8ass\n"
"vbv7+uznADzHsMiG/ZlLAEkQJ9j0ENJvHmnayeVFIXDV6jPCcQJ+rURDgl7z\n"
"/qTLfe3o3zBMG78LcB+xDNXTQrK5Z0LX7h17hLSElpiUghFa9nviCsT0nkcr\n"
"nz302P4IOFwJuYMMCEfW+ywTn+CHpKjLHWkZSZ4q6LzNTbbgXZn/vh7njNf0\n"
"QHaHmaMNxnDhUw/Bl13uM52qtsfEYK07SEhLFlJbAk0G7q+OabK8dJxCRwS3\n"
"X9k4juzLUYhX8XBovg9G3YEVckb6iM8/LF/yvNXbUsPrdhYU9lPA63xD0Pgb\n"
"zthZCLIlnF+lS6e41WJv3n1dc4dFWD7F5tmt/7uwLC6oUGYsccSzY+bUkYhL\n"
"dp7tlQRd5AG/Xz8XilORk8cUjvi6uZss5LyQpKvGSU+77C8ZV/oS62BdS5TE\n"
"osBTrO2/9FGzQtHT+8DJSTPPgR6rcQUWLPemiG09ACKfRQ/g3b9Qj0upOcKL\n"
"6dti0lq7Aorc39vV18DPMFBOwzchUEBlBFyuSa4AoD30tsoilAC3qbzBwu3z\n"
"QLjmst76HEcWDkxgDAhlBz6/XgiVZsCivn7ygigmc2+hNEzIdDsKKfM9bkoe\n"
"3uJzmmsv8Bh5ZEtfGoGNmu/zA7tgvTOCBeotYeHr2O6pLmYb3hK+E/qCBl14\n"
"8pK4qYrjAlF+ZMq9BzXcaz5mRfKVfAQtghHOaNqopBczSE1bjFF6HaNhIaGa\n"
"N8YdabNQG7mLI/fgBxJfkPl6HdIhEpctp4RURbSFhW+wn0o85VyHM6a+6Vgj\n"
"NrYmhxPZ6N1KN0Qy76aNiw7nAToRRcOv87uZnkDIeVH8mP/0hldyiy/Y97cG\n"
"QgOeQHOG27QW57nHhqLRqvf0zzQZekuXWFbqajpaabEcdGXyiUpJ8/ZopBPM\n"
"AJwfkyA2LkV946IA4JV6sPnu9pYzpXQ4vdQKJ6DoDUyRTQmgmfSFGtfHAozY\n"
"V9k0iQeetSkYYtOagTrg3t92v7M00o/NJW/rKX4jj2djD8wtBovOcv4kxg4Z\n"
"o58Iv94ROim48XfyesvSYKN1xqqbXH4sfE6b4b9pLUxQVOmWANLK9MK8D+Ci\n"
"IvrGbz5U5bZP6vlNbe9bYzjvWTPjaMrjXknRTBcikavqOfDTSIVFtT4qvhvK\n"
"42PpOrm0qdiLwExGKQ9FfEfYZRgEcYRGg7rH3oNz6ZNOEXppF3tCl9yVOlFb\n"
"ygdIeT3Z3HeOQbAsi8jK7o16DSXL7ZOpFq9Bv9yzusrF7Eht/fSEpAVUO3D1\n"
"IuqjZcsQRhMtIvnF0oFujFtooJx9x3dj/RarvEGX/NzwATZkgJ+yWs2etruA\n"
"EzMQqED4j7Lb790zEWnt+nuHdCdlPnNy8RG5u5X62p3h5KqUbg9HfmIuuESi\n"
"hwr6dKsVQGc5XUB5KTt0dtjWlK5iaetDsZFuF5+aE0Xa6PmiQ2e7ZPFyxXmO\n"
"T/PSHzobx0qClKCu+tSWA1HDSL08IeoGZEyyhoaxyn5D9r1Mqg101v/iu59r\n"
"lRRs+plAhbuq5aQA3WKtF1N6Zb5+AVRpNUyrxyHoH36ddR4/n7lnIld3STGD\n"
"RqZLrOuKHS3dCNW2Pt15lU+loYsWFZwC6T/tAbvwhax+XaBMiKQSDFmG9sBw\n"
"TiM1JWXhq2IsjXBvCl6k2AKWLQOvc/Hin+oYs4d7M9mi0vdoEOAMadU/+Pqn\n"
"uZzP941mOUV5UeTCCbjpyfI7qtIi3TH1cQmC2kG2HrvQYuM6Momp//JusH1+\n"
"9eHgFo25HbitcKJ1sAqxsnYIW5/jIVyIJC7tatxmNfFQQ/LUb2cT+Jowwsf4\n"
"bbPinA9S6aQFy9k3vk07V2ouYl+cpMMXmNAUrboFRLxw7QDapWYMKdmnbU5O\n"
"HZuDz3iyrm0lMPsRtt/f5WUhZYY4vXT5/dj+8P6Pr5fdc4S84i5qEzf7bX/I\n"
"Sc6fpISdYBscfHdv6uXsEVtVPKEuQVYwhyc4kkwVKjZBaqsgjAA7VEhQXzO3\n"
"rC7di4UhabWQCQTG1GYZyrj4bm6dg/32uVxMoLS5kuSpi3nMz5JmQahLqRxh\n"
"argg13K2/MJ7w2AI23gCvO5bEmD1ZXIi1aGYdZfu7+KqrTumYxj0KgIesgU0\n"
"6ekmPh4Zu5lIyKopa89nfQVj3uKbwr9LLHegfzeMhvI5WQWghKcNcXEvJwSA\n"
"vEik5aXm2qSKXT+ijXBy5MuNeICoGaQ5WA0OJ30Oh5dN0XpLtFUWHZKThJvR\n"
"mngm1QCMMw2v/j8=\n"
"=9sJE\n"
"-----END PGP MESSAGE-----\n";
void stress_functions(dc_context_t* context)
{
/* test dc_saxparser_t
**************************************************************************/
{
dc_saxparser_t saxparser;
dc_saxparser_init(&saxparser, NULL);
dc_saxparser_parse(&saxparser, "<tag attr=val="); // should not crash or cause a deadlock
dc_saxparser_parse(&saxparser, "<tag attr=\"val\"="); // should not crash or cause a deadlock
}
/* test dc_simplify_t and dc_saxparser_t (indirectly used by dc_simplify_t)
**************************************************************************/
{
dc_simplify_t* simplify = dc_simplify_new();
const char* html = "\r\r\nline1<br>\r\n\r\n\r\rline2\n\r"; /* check, that `<br>\ntext` does not result in `\n text` */
char* plain = dc_simplify_simplify(simplify, html, strlen(html), 1, 0);
assert( strcmp(plain, "line1\nline2")==0 );
free(plain);
html = "<a href=url>text</a"; /* check unquoted attribute and unclosed end-tag */
plain = dc_simplify_simplify(simplify, html, strlen(html), 1, 0);
assert( strcmp(plain, "[text](url)")==0 );
free(plain);
html = "<!DOCTYPE name [<!DOCTYPE ...>]><!-- comment -->text <b><?php echo ... ?>bold</b><![CDATA[<>]]>";
plain = dc_simplify_simplify(simplify, html, strlen(html), 1, 0);
assert( strcmp(plain, "text *bold*<>")==0 );
free(plain);
html = "&lt;&gt;&quot;&apos;&amp; &auml;&Auml;&ouml;&Ouml;&uuml;&Uuml;&szlig; foo&AElig;&ccedil;&Ccedil; &diams;&noent;&lrm;&rlm;&zwnj;&zwj;";
plain = dc_simplify_simplify(simplify, html, strlen(html), 1, 0);
assert( strcmp(plain, "<>\"'& äÄöÖüÜß fooÆçÇ ♦&noent;")==0 );
free(plain);
dc_simplify_unref(simplify);
}
{
const char* xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n"
"<Document addr=\"user@example.org\">\n"
"<Placemark><Timestamp><when>2019-03-06T21:09:57Z</when></Timestamp><Point><coordinates accuracy=\"32.000000\">9.423110,53.790302</coordinates></Point></Placemark>\n"
"<PlaceMARK>\n<Timestamp><WHEN > \n\t2018-12-13T22:11:12Z\t</wHeN></Timestamp><Point><coordinates aCCuracy=\"2.500000\"> 19.423110 \t , \n 63.790302\n </coordinates></Point></Placemark>\n"
"</Document>\n"
"</kml>";
dc_kml_t* kml = dc_kml_parse(context, xml, strlen(xml));
assert( kml->addr && strcmp(kml->addr, "user@example.org")==0 );
assert( dc_array_get_cnt(kml->locations)==2 );
double lat = dc_array_get_latitude (kml->locations, 0); assert (lat>53.6 && lat<53.8);
double lng = dc_array_get_longitude(kml->locations, 0); assert (lng> 9.3 && lng< 9.5);
double acc = dc_array_get_accuracy (kml->locations, 0); assert (acc>31.9 && acc<32.1);
assert( dc_array_get_timestamp(kml->locations, 0)==1551906597 );
lat = dc_array_get_latitude (kml->locations, 1); assert (lat>63.6 && lat<63.8);
lng = dc_array_get_longitude(kml->locations, 1); assert (lng>19.3 && lng<19.5);
acc = dc_array_get_accuracy (kml->locations, 1); assert (acc> 2.4 && acc< 2.6);
assert( dc_array_get_timestamp(kml->locations, 1)==1544739072 );
dc_kml_unref(kml);
}
/* test file functions
**************************************************************************/
if (dc_is_open(context))
{
if (dc_file_exist(context, "$BLOBDIR/foobar")
|| dc_file_exist(context, "$BLOBDIR/dada")
|| dc_file_exist(context, "$BLOBDIR/foobar.dadada")
|| dc_file_exist(context, "$BLOBDIR/foobar-folder")) {
dc_delete_file(context, "$BLOBDIR/foobar");
dc_delete_file(context, "$BLOBDIR/dada");
dc_delete_file(context, "$BLOBDIR/foobar.dadada");
dc_delete_file(context, "$BLOBDIR/foobar-folder");
}
dc_write_file(context, "$BLOBDIR/foobar", "content", 7);
assert( dc_file_exist(context, "$BLOBDIR/foobar") );
assert( !dc_file_exist(context, "$BLOBDIR/foobarx") );
assert( dc_get_filebytes(context, "$BLOBDIR/foobar")==7 );
char* absPath = dc_mprintf("%s/%s", context->blobdir, "foobar");
assert( dc_is_blobdir_path(context, absPath) );
assert( dc_is_blobdir_path(context, "$BLOBDIR/fofo") );
assert( !dc_is_blobdir_path(context, "/BLOBDIR/fofo") );
assert( dc_file_exist(context, absPath) );
free(absPath);
assert( dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada") );
assert( dc_get_filebytes(context, "$BLOBDIR/dada")==7 );
void* buf;
size_t buf_bytes;
assert( dc_read_file(context, "$BLOBDIR/dada", &buf, &buf_bytes) );
assert( buf_bytes==7 );
assert( strcmp(buf, "content")==0 );
free(buf);
assert( dc_delete_file(context, "$BLOBDIR/foobar") );
assert( dc_delete_file(context, "$BLOBDIR/dada") );
assert( dc_create_folder(context, "$BLOBDIR/foobar-folder") );
assert( dc_file_exist(context, "$BLOBDIR/foobar-folder") );
assert( dc_delete_file(context, "$BLOBDIR/foobar-folder") );
char* fn0 = dc_get_fine_pathNfilename(context, "$BLOBDIR", "foobar.dadada");
assert( fn0 );
assert( strcmp(fn0, "$BLOBDIR/foobar.dadada")==0 );
dc_write_file(context, fn0, "content", 7);
char* fn1 = dc_get_fine_pathNfilename(context, "$BLOBDIR", "foobar.dadada");
assert( fn1 );
assert( strcmp(fn1, "$BLOBDIR/foobar-1.dadada")==0 );
assert( dc_delete_file(context, fn0) );
free(fn0);
free(fn1);
}
/* test mailmime
**************************************************************************/
{
const char* txt = "FieldA: ValueA\nFieldB: ValueB\n";
struct mailmime* mime = NULL;
size_t dummy = 0;
assert( mailmime_parse(txt, strlen(txt), &dummy, &mime) == MAIL_NO_ERROR );
assert( mime != NULL );
struct mailimf_fields* fields = mailmime_find_mailimf_fields(mime);
assert( fields != NULL );
struct mailimf_optional_field* of_a = mailimf_find_optional_field(fields, "fielda");
assert( of_a && of_a->fld_value );
assert( strcmp(of_a->fld_name, "FieldA")==0 );
assert( strcmp(of_a->fld_value, "ValueA")==0 );
of_a = mailimf_find_optional_field(fields, "FIELDA");
assert( of_a && of_a->fld_value );
assert( strcmp(of_a->fld_name, "FieldA")==0 );
assert( strcmp(of_a->fld_value, "ValueA")==0 );
struct mailimf_optional_field* of_b = mailimf_find_optional_field(fields, "FieldB");
assert( of_b && of_b->fld_value );
assert( strcmp(of_b->fld_value, "ValueB")==0 );
mailmime_free(mime);
}
/* test dc_mimeparser_t
**************************************************************************/
{
dc_mimeparser_t* mimeparser = dc_mimeparser_new(context->blobdir, context);
const char* raw =
"Content-Type: multipart/mixed; boundary=\"==break==\";\n"
"Subject: outer-subject\n"
"X-Special-A: special-a\n"
"Foo: Bar\n"
"Chat-Version: 0.0\n"
"\n"
"--==break==\n"
"Content-Type: text/plain; protected-headers=\"v1\";\n"
"Subject: inner-subject\n"
"X-Special-B: special-b\n"
"Foo: Xy\n"
"Chat-Version: 1.0\n"
"\n"
"test1\n"
"\n"
"--==break==--\n"
"\n";
dc_mimeparser_parse(mimeparser, raw, strlen(raw));
assert( strcmp(mimeparser->subject, "inner-subject")==0 );
struct mailimf_optional_field* of = dc_mimeparser_lookup_optional_field(mimeparser, "X-Special-A");
assert( strcmp(of->fld_value, "special-a")==0 );
of = dc_mimeparser_lookup_optional_field(mimeparser, "Foo");
assert( strcmp(of->fld_value, "Bar")==0 ); /* completely unknown values are not overwritten */
of = dc_mimeparser_lookup_optional_field(mimeparser, "Chat-Version");
assert( strcmp(of->fld_value, "1.0")==0 );
assert( carray_count(mimeparser->parts) == 1 );
dc_mimeparser_unref(mimeparser);
}
/* test message helpers
**************************************************************************/
{
int type;
char* mime;
dc_msg_guess_msgtype_from_suffix("foo/bar-sth.mp3", NULL, NULL);
dc_msg_guess_msgtype_from_suffix("foo/bar-sth.mp3", NULL, &mime);
assert( strcmp(mime, "audio/mpeg")==0 );
dc_msg_guess_msgtype_from_suffix("foo/bar-sth.mp3", &type, NULL);
assert( type == DC_MSG_AUDIO );
free(mime);
}
/* test some string functions and macros
**************************************************************************/
{
assert( atol("")==0 ); /* we rely on this eg. in dc_sqlite3_get_config() */
assert( atoi("")==0 );
double f = dc_atof("1.23");
assert( f>1.22 && f<1.24 );
char* s = dc_ftoa(1.23);
assert( dc_atof(s)>1.22 && dc_atof(s)<1.24 );
free(s);
assert( !dc_may_be_valid_addr(NULL) );
assert( !dc_may_be_valid_addr("") );
assert( dc_may_be_valid_addr("user@domain.tld") );
assert( !dc_may_be_valid_addr("uuu") );
assert( !dc_may_be_valid_addr("dd.tt") );
assert( !dc_may_be_valid_addr("tt.dd@uu") );
assert( !dc_may_be_valid_addr("uu") );
assert( !dc_may_be_valid_addr("u@d") );
assert( !dc_may_be_valid_addr("u@d.") );
assert( !dc_may_be_valid_addr("u@d.t") );
assert( dc_may_be_valid_addr("u@d.tt") );
assert( !dc_may_be_valid_addr("u@.tt") );
assert( !dc_may_be_valid_addr("@d.tt") );
char* str = strdup("aaa");
int replacements = dc_str_replace(&str, "a", "ab"); /* no endless recursion here! */
assert( strcmp(str, "ababab")==0 );
assert( replacements == 3 );
free(str);
str = strdup("this is a little test string");
dc_truncate_str(str, 16);
assert( strcmp(str, "this is a " DC_EDITORIAL_ELLIPSE)==0 );
free(str);
str = strdup("1234");
dc_truncate_str(str, 2);
assert( strcmp(str, "1234")==0 );
free(str);
str = strdup("1234567");
dc_truncate_str(str, 1);
assert( strcmp(str, "1[...]")==0 );
free(str);
str = strdup("123456");
dc_truncate_str(str, 4);
assert( strcmp(str, "123456")==0 );
free(str);
str = dc_insert_breaks("just1234test", 4, " ");
assert( strcmp(str, "just 1234 test")==0 );
free(str);
str = dc_insert_breaks("just1234tes", 4, "--");
assert( strcmp(str, "just--1234--tes")==0 );
free(str);
str = dc_insert_breaks("just1234t", 4, "");
assert( strcmp(str, "just1234t")==0 );
free(str);
str = dc_insert_breaks("", 4, "---");
assert( strcmp(str, "")==0 );
free(str);
str = dc_null_terminate("abcxyz", 3);
assert( strcmp(str, "abc")==0 );
free(str);
str = dc_null_terminate("abcxyz", 0);
assert( strcmp(str, "")==0 );
free(str);
str = dc_null_terminate(NULL, 0);
assert( strcmp(str, "")==0 );
free(str);
clist* list = dc_str_to_clist(NULL, " ");
assert( clist_count(list)==0 );
clist_free_content(list);
clist_free(list);
list = dc_str_to_clist("", " ");
assert( clist_count(list)==1 );
clist_free_content(list);
clist_free(list);
list = dc_str_to_clist(" ", " ");
assert( clist_count(list)==2 );
clist_free_content(list);
clist_free(list);
list = dc_str_to_clist("foo bar test", " ");
assert(clist_count(list)==3);
str = dc_str_from_clist(list, " ");
assert( strcmp(str, "foo bar test")==0 );
clist_free_content(list);
clist_free(list);
free(str);
assert( strcmp("fresh=" DC_STRINGIFY(DC_STATE_IN_FRESH), "fresh=10")==0 ); /* these asserts check the values, the existance of the macros and also DC_STRINGIFY() */
assert( strcmp("noticed=" DC_STRINGIFY(DC_STATE_IN_NOTICED), "noticed=13")==0 );
assert( strcmp("seen=" DC_STRINGIFY(DC_STATE_IN_SEEN), "seen=16")==0 );
assert( strcmp("pending=" DC_STRINGIFY(DC_STATE_OUT_PENDING), "pending=20")==0 );
assert( strcmp("failed=" DC_STRINGIFY(DC_STATE_OUT_FAILED), "failed=24")==0 );
assert( strcmp("delivered=" DC_STRINGIFY(DC_STATE_OUT_DELIVERED), "delivered=26")==0 );
assert( strcmp("mdn_rcvd=" DC_STRINGIFY(DC_STATE_OUT_MDN_RCVD), "mdn_rcvd=28")==0 );
assert( strcmp("undefined=" DC_STRINGIFY(DC_CHAT_TYPE_UNDEFINED), "undefined=0")==0 );
assert( strcmp("single=" DC_STRINGIFY(DC_CHAT_TYPE_SINGLE), "single=100")==0 );
assert( strcmp("group=" DC_STRINGIFY(DC_CHAT_TYPE_GROUP), "group=120")==0 );
assert( strcmp("vgroup=" DC_STRINGIFY(DC_CHAT_TYPE_VERIFIED_GROUP), "vgroup=130")==0 );
assert( strcmp("deaddrop=" DC_STRINGIFY(DC_CHAT_ID_DEADDROP), "deaddrop=1")==0 );
assert( strcmp("trash=" DC_STRINGIFY(DC_CHAT_ID_TRASH), "trash=3")==0 );
assert( strcmp("in_creation=" DC_STRINGIFY(DC_CHAT_ID_MSGS_IN_CREATION), "in_creation=4")==0 );
assert( strcmp("starred=" DC_STRINGIFY(DC_CHAT_ID_STARRED), "starred=5")==0 );
assert( strcmp("archivedlink=" DC_STRINGIFY(DC_CHAT_ID_ARCHIVED_LINK), "archivedlink=6")==0 );
assert( strcmp("spcl_chat=" DC_STRINGIFY(DC_CHAT_ID_LAST_SPECIAL), "spcl_chat=9")==0 );
assert( strcmp("self=" DC_STRINGIFY(DC_CONTACT_ID_SELF), "self=1")==0 );
assert( strcmp("spcl_contact=" DC_STRINGIFY(DC_CONTACT_ID_LAST_SPECIAL), "spcl_contact=9")==0 );
assert( strcmp("grpimg=" DC_STRINGIFY(DC_CMD_GROUPIMAGE_CHANGED), "grpimg=3")==0 );
assert( strcmp("notverified=" DC_STRINGIFY(DC_NOT_VERIFIED), "notverified=0")==0 );
assert( strcmp("bidirectional=" DC_STRINGIFY(DC_BIDIRECT_VERIFIED), "bidirectional=2")==0 );
assert( strcmp("public=" DC_STRINGIFY(DC_KEY_PUBLIC), "public=0")==0 );
assert( strcmp("private=" DC_STRINGIFY(DC_KEY_PRIVATE), "private=1")==0 );
assert( DC_PARAM_FILE == 'f' );
assert( DC_PARAM_WIDTH == 'w' );
assert( DC_PARAM_HEIGHT == 'h' );
assert( DC_PARAM_DURATION == 'd' );
assert( DC_PARAM_MIMETYPE == 'm' );
assert( DC_PARAM_FORWARDED == 'a' );
assert( DC_PARAM_UNPROMOTED == 'U' );
char* buf1 = strdup("ol\xc3\xa1 mundo <>\"'& äÄöÖüÜß fooÆçÇ ♦&noent;"); char* buf2 = strdup(buf1);
dc_replace_bad_utf8_chars(buf2);
assert( strcmp(buf1, buf2)==0 );
free(buf1); free(buf2);
buf1 = strdup("ISO-String with Ae: \xC4"); buf2 = strdup(buf1);
dc_replace_bad_utf8_chars(buf2);
assert( strcmp("ISO-String with Ae: _", buf2)==0 );
free(buf1); free(buf2);
buf1 = strdup(""); buf2 = strdup(buf1);
dc_replace_bad_utf8_chars(buf2);
assert( buf2[0]==0 );
free(buf1); free(buf2);
dc_replace_bad_utf8_chars(NULL); /* should do nothing */
buf1 = dc_urlencode("Björn Petersen");
assert( strcmp(buf1, "Bj%C3%B6rn+Petersen") == 0 );
buf2 = dc_urldecode(buf1);
assert( strcmp(buf2, "Björn Petersen") == 0 );
free(buf1); free(buf2);
buf1 = dc_create_id();
assert( strlen(buf1) == DC_CREATE_ID_LEN );
free(buf1);
buf1 = dc_decode_header_words("=?utf-8?B?dGVzdMOkw7bDvC50eHQ=?=");
assert( strcmp(buf1, "testäöü.txt")==0 );
free(buf1);
buf1 = dc_decode_header_words("just ascii test");
assert( strcmp(buf1, "just ascii test")==0 );
free(buf1);
buf1 = dc_encode_header_words("abcdef");
assert( strcmp(buf1, "abcdef")==0 );
free(buf1);
buf1 = dc_encode_header_words("testäöü.txt");
assert( strncmp(buf1, "=?utf-8", 7)==0 );
buf2 = dc_decode_header_words(buf1);
assert( strcmp("testäöü.txt", buf2)==0 );
free(buf1);
free(buf2);
buf1 = dc_decode_header_words("=?ISO-8859-1?Q?attachment=3B=0D=0A_filename=3D?= =?ISO-8859-1?Q?=22test=E4=F6=FC=2Etxt=22=3B=0D=0A_size=3D39?=");
assert( strcmp(buf1, "attachment;\r\n filename=\"testäöü.txt\";\r\n size=39")==0 );
free(buf1);
buf1 = dc_encode_ext_header("Björn Petersen");
assert( strcmp(buf1, "utf-8''Bj%C3%B6rn%20Petersen") == 0 );
buf2 = dc_decode_ext_header(buf1);
assert( strcmp(buf2, "Björn Petersen") == 0 );
free(buf1);
free(buf2);
buf1 = dc_decode_ext_header("iso-8859-1'en'%A3%20rates");
assert( strcmp(buf1, "£ rates") == 0 );
assert( strcmp(buf1, "\xC2\xA3 rates") == 0 );
free(buf1);
buf1 = dc_decode_ext_header("wrong'format"); // bad format -> should return given string
assert( strcmp(buf1, "wrong'format") == 0 );
free(buf1);
buf1 = dc_decode_ext_header("''"); // empty charset -> should return given string
assert( strcmp(buf1, "''") == 0 );
free(buf1);
buf1 = dc_decode_ext_header("x''"); // charset given -> return empty encoded string
assert( strcmp(buf1, "") == 0 );
free(buf1);
buf1 = dc_decode_ext_header("'"); // bad format -> should return given string
assert( strcmp(buf1, "'") == 0 );
free(buf1);
buf1 = dc_decode_ext_header(""); // bad format -> should return given string - empty in this case
assert( strcmp(buf1, "") == 0 );
free(buf1);
assert( dc_needs_ext_header("Björn") );
assert( !dc_needs_ext_header("Bjoern") );
assert( !dc_needs_ext_header("") );
assert( dc_needs_ext_header(" ") );
assert( dc_needs_ext_header("a b") );
assert( !dc_needs_ext_header(NULL) );
buf1 = dc_encode_modified_utf7("Björn Petersen", 1);
assert( strcmp(buf1, "Bj&APY-rn_Petersen")==0 );
buf2 = dc_decode_modified_utf7(buf1, 1);
assert( strcmp(buf2, "Björn Petersen")==0 );
free(buf1);
free(buf2);
assert( DC_EVENT_DATA1_IS_STRING(2100) );
assert( DC_EVENT_DATA1_IS_STRING(2052) );
assert( !DC_EVENT_DATA1_IS_STRING(100) );
assert( !DC_EVENT_DATA1_IS_STRING(300) );
assert( !DC_EVENT_DATA1_IS_STRING(400) );
assert( DC_EVENT_DATA2_IS_STRING(100) );
assert( DC_EVENT_DATA2_IS_STRING(300) );
assert( DC_EVENT_DATA2_IS_STRING(400) );
assert( !DC_EVENT_DATA2_IS_STRING(2010) );
assert( DC_EVENT_RETURNS_STRING(2091) );
assert( DC_EVENT_RETURNS_STRING(2100) );
assert( !DC_EVENT_RETURNS_STRING(100) );
assert( !DC_EVENT_RETURNS_STRING(300) );
assert( !DC_EVENT_RETURNS_STRING(400) );
assert( dc_utf8_strlen("c")==1 && strlen("c")==1 );
assert( dc_utf8_strlen("ä")==1 && strlen("ä")==2 );
}
/* test dc_array_t
**************************************************************************/
{
#define TEST_CNT 1000
dc_array_t* arr = dc_array_new(NULL, 7);
assert( dc_array_get_cnt(arr) == 0 );
int i;
for (i = 0; i < TEST_CNT; i++) {
dc_array_add_id(arr, i+1*2);
}
assert( dc_array_get_cnt(arr) == TEST_CNT );
for (i = 0; i< TEST_CNT; i++) {
assert( dc_array_get_id(arr, i) == i+1*2 );
}
assert( dc_array_get_id(arr, -1) == 0 ); /* test out-of-range access */
assert( dc_array_get_id(arr, TEST_CNT) == 0 ); /* test out-of-range access */
assert( dc_array_get_id(arr, TEST_CNT+1) == 0 ); /* test out-of-range access */
dc_array_empty(arr);
assert( dc_array_get_cnt(arr) == 0 );
dc_array_add_id(arr, 13);
dc_array_add_id(arr, 7);
dc_array_add_id(arr, 666);
dc_array_add_id(arr, 0);
dc_array_add_id(arr, 5000);
dc_array_sort_ids(arr);
assert( dc_array_get_id(arr, 0)==0 && dc_array_get_id(arr, 1)==7 && dc_array_get_id(arr, 2)==13 && dc_array_get_id(arr, 3)==666 );
char* str = dc_array_get_string(arr, "-");
assert( strcmp(str, "0-7-13-666-5000")==0 );
free(str);
const uint32_t arr2[] = { 0, 12, 133, 1999999 };
str = dc_arr_to_string(arr2, 4);
assert( strcmp(str, "0,12,133,1999999")==0 );
free(str);
dc_array_empty(arr);
dc_array_add_ptr(arr, "XX");
dc_array_add_ptr(arr, "item1");
dc_array_add_ptr(arr, "bbb");
dc_array_add_ptr(arr, "aaa");
dc_array_sort_strings(arr);
assert( strcmp("XX", (char*)dc_array_get_ptr(arr, 0))==0 );
assert( strcmp("aaa", (char*)dc_array_get_ptr(arr, 1))==0 );
assert( strcmp("bbb", (char*)dc_array_get_ptr(arr, 2))==0 );
assert( strcmp("item1", (char*)dc_array_get_ptr(arr, 3))==0 );
dc_array_unref(arr);
}
/* test dc_param
**************************************************************************/
{
dc_param_t* p1 = dc_param_new();
dc_param_set_packed(p1, "\r\n\r\na=1\nb=2\n\nc = 3 ");
assert( dc_param_get_int(p1, 'a', 0)==1 );
assert( dc_param_get_int(p1, 'b', 0)==2 );
assert( dc_param_get_int(p1, 'c', 0)==0 ); /* c is not accepted, spaces and weird characters are not allowed in param, were very strict there */
assert( dc_param_exists (p1, 'c')==0 );
dc_param_set_int(p1, 'd', 4);
assert( dc_param_get_int(p1, 'd', 0)==4 );
dc_param_empty(p1);
dc_param_set (p1, 'a', "foo");
dc_param_set_int(p1, 'b', 2);
dc_param_set (p1, 'c', NULL);
dc_param_set_int(p1, 'd', 4);
assert( strcmp(p1->packed, "a=foo\nb=2\nd=4")==0 );
dc_param_set (p1, 'b', NULL);
assert( strcmp(p1->packed, "a=foo\nd=4")==0 );
dc_param_set (p1, 'a', NULL);
dc_param_set (p1, 'd', NULL);
assert( strcmp(p1->packed, "")==0 );
dc_param_unref(p1);
}
/* test keys for dc_set_config() and dc_get_config()
**************************************************************************/
{
char* keys = dc_get_config(context, "sys.config_keys");
assert( keys && keys[0] );
dc_strbuilder_t sb;
dc_strbuilder_init(&sb, 200);
dc_strbuilder_catf(&sb, " %s ", keys);
free(keys);
keys = sb.buf;
assert( strstr(keys, " probably_never_a_key ")==NULL );
assert( strstr(keys, " addr ")!=NULL );
assert( strstr(keys, " mail_server ")!=NULL );
assert( strstr(keys, " mail_user ")!=NULL );
assert( strstr(keys, " mail_pw ")!=NULL );
assert( strstr(keys, " mail_port ")!=NULL );
assert( strstr(keys, " send_server ")!=NULL );
assert( strstr(keys, " send_user ")!=NULL );
assert( strstr(keys, " send_pw ")!=NULL );
assert( strstr(keys, " send_port ")!=NULL );
assert( strstr(keys, " server_flags ")!=NULL );
assert( strstr(keys, " imap_folder ")!=NULL );
assert( strstr(keys, " displayname ")!=NULL );
assert( strstr(keys, " selfstatus ")!=NULL );
assert( strstr(keys, " selfavatar ")!=NULL );
assert( strstr(keys, " e2ee_enabled ")!=NULL );
assert( strstr(keys, " mdns_enabled ")!=NULL );
assert( strstr(keys, " save_mime_headers ")!=NULL );
assert( strstr(keys, " configured_addr ")!=NULL );
assert( strstr(keys, " configured_mail_server ")!=NULL );
assert( strstr(keys, " configured_mail_user ")!=NULL );
assert( strstr(keys, " configured_mail_pw ")!=NULL );
assert( strstr(keys, " configured_mail_port ")!=NULL );
assert( strstr(keys, " configured_send_server ")!=NULL );
assert( strstr(keys, " configured_send_user ")!=NULL );
assert( strstr(keys, " configured_send_pw ")!=NULL );
assert( strstr(keys, " configured_send_port ")!=NULL );
assert( strstr(keys, " configured_server_flags ")!=NULL );
free(keys);
}
/* test Autocrypt header parsing functions
**************************************************************************/
{
dc_aheader_t* ah = dc_aheader_new();
char* rendered = NULL;
int ah_ok;
ah_ok = dc_aheader_set_from_string(ah, "addr=a@b.example.org; prefer-encrypt=mutual; keydata=RGVsdGEgQ2hhdA==");
assert( ah_ok == 1 );
assert( ah->addr && strcmp(ah->addr, "a@b.example.org")==0 );
assert( ah->public_key->bytes==10 && strncmp((char*)ah->public_key->binary, "Delta Chat", 10)==0 );
assert( ah->prefer_encrypt==DC_PE_MUTUAL );
rendered = dc_aheader_render(ah);
assert( rendered && strcmp(rendered, "addr=a@b.example.org; prefer-encrypt=mutual; keydata= RGVsdGEgQ2hhdA==")==0 );
ah_ok = dc_aheader_set_from_string(ah, " _foo; __FOO=BAR ;;; addr = a@b.example.org ;\r\n prefer-encrypt = mutual ; keydata = RG VsdGEgQ\r\n2hhdA==");
assert( ah_ok == 1 );
assert( ah->addr && strcmp(ah->addr, "a@b.example.org")==0 );
assert( ah->public_key->bytes==10 && strncmp((char*)ah->public_key->binary, "Delta Chat", 10)==0 );
assert( ah->prefer_encrypt==DC_PE_MUTUAL );
ah_ok = dc_aheader_set_from_string(ah, "addr=a@b.example.org; prefer-encrypt=ignoreUnknownValues; keydata=RGVsdGEgQ2hhdA==");
assert( ah_ok == 1 ); /* only "yes" or "no" are valid for prefer-encrypt ... */
ah_ok = dc_aheader_set_from_string(ah, "addr=a@b.example.org; keydata=RGVsdGEgQ2hhdA==");
assert( ah_ok == 1 && ah->prefer_encrypt==DC_PE_NOPREFERENCE ); /* ... "nopreference" is use if the attribute is missing (see Autocrypt-Level0) */
ah_ok = dc_aheader_set_from_string(ah, "");
assert( ah_ok == 0 );
ah_ok = dc_aheader_set_from_string(ah, ";");
assert( ah_ok == 0 );
ah_ok = dc_aheader_set_from_string(ah, "foo");
assert( ah_ok == 0 );
ah_ok = dc_aheader_set_from_string(ah, "\n\n\n");
assert( ah_ok == 0 );
ah_ok = dc_aheader_set_from_string(ah, " ;;");
assert( ah_ok == 0 );
ah_ok = dc_aheader_set_from_string(ah, "addr=a@t.de; unknwon=1; keydata=jau"); /* unknwon non-underscore attributes result in invalid headers */
assert( ah_ok == 0 );
dc_aheader_unref(ah);
free(rendered);
}
/* test PGP armor parsing
**************************************************************************/
{
int ok;
char *buf;
const char *headerline, *setupcodebegin, *preferencrypt, *base64;
buf = strdup("-----BEGIN PGP MESSAGE-----\nNoVal:\n\ndata\n-----END PGP MESSAGE-----");
ok = dc_split_armored_data(buf, &headerline, &setupcodebegin, NULL, &base64);
assert( ok == 1 );
assert( headerline && strcmp(headerline, "-----BEGIN PGP MESSAGE-----")==0 );
assert( base64 && strcmp(base64, "data") == 0 );
free(buf);
buf = strdup("-----BEGIN PGP MESSAGE-----\n\ndat1\n-----END PGP MESSAGE-----\n-----BEGIN PGP MESSAGE-----\n\ndat2\n-----END PGP MESSAGE-----");
ok = dc_split_armored_data(buf, &headerline, &setupcodebegin, NULL, &base64);
assert( ok == 1 );
assert( headerline && strcmp(headerline, "-----BEGIN PGP MESSAGE-----")==0 );
assert( base64 && strcmp(base64, "dat1") == 0 );
free(buf);
buf = strdup("foo \n -----BEGIN PGP MESSAGE----- \n base64-123 \n -----END PGP MESSAGE-----");
ok = dc_split_armored_data(buf, &headerline, &setupcodebegin, NULL, &base64);
assert( ok == 1 );
assert( headerline && strcmp(headerline, "-----BEGIN PGP MESSAGE-----")==0 );
assert( setupcodebegin == NULL );
assert( base64 && strcmp(base64, "base64-123")==0 );
free(buf);
buf = strdup("foo-----BEGIN PGP MESSAGE-----");
ok = dc_split_armored_data(buf, &headerline, &setupcodebegin, NULL, &base64);
assert( ok == 0 );
free(buf);
buf = strdup("foo \n -----BEGIN PGP MESSAGE-----\n Passphrase-BeGIN : 23 \n \n base64-567 \r\n abc \n -----END PGP MESSAGE-----\n\n\n");
ok = dc_split_armored_data(buf, &headerline, &setupcodebegin, NULL, &base64);
assert( ok == 1 );
assert( headerline && strcmp(headerline, "-----BEGIN PGP MESSAGE-----")==0 );
assert( setupcodebegin && strcmp(setupcodebegin, "23")==0 );
assert( base64 && strcmp(base64, "base64-567 \n abc")==0 );
free(buf);
buf = strdup("-----BEGIN PGP PRIVATE KEY BLOCK-----\n Autocrypt-Prefer-Encrypt : mutual \n\nbase64\n-----END PGP PRIVATE KEY BLOCK-----");
ok = dc_split_armored_data(buf, &headerline, NULL, &preferencrypt, &base64);
assert( ok == 1 );
assert( headerline && strcmp(headerline, "-----BEGIN PGP PRIVATE KEY BLOCK-----")==0 );
assert( preferencrypt && strcmp(preferencrypt, "mutual")==0 );
assert( base64 && strcmp(base64, "base64")==0 );
free(buf);
}
/* test Autocrypt Setup Message
**************************************************************************/
{
char* norm = dc_normalize_setup_code(context, "123422343234423452346234723482349234");
assert( norm );
assert( strcmp(norm, "1234-2234-3234-4234-5234-6234-7234-8234-9234") == 0 );
free(norm);
norm = dc_normalize_setup_code(context, "\t1 2 3422343234- foo bar-- 423-45 2 34 6234723482349234 ");
assert( norm );
assert( strcmp(norm, "1234-2234-3234-4234-5234-6234-7234-8234-9234") == 0 );
free(norm);
}
{
char* buf = NULL;
const char *headerline = NULL, *setupcodebegin = NULL, *preferencrypt = NULL;
buf = strdup(s_em_setupfile);
assert( dc_split_armored_data(buf, &headerline, &setupcodebegin, &preferencrypt, NULL) );
assert( headerline && strcmp(headerline, "-----BEGIN PGP MESSAGE-----")==0 );
assert( setupcodebegin && strlen(setupcodebegin)<strlen(s_em_setupcode) && strncmp(setupcodebegin, s_em_setupcode, strlen(setupcodebegin))==0 );
assert( preferencrypt==NULL );
free(buf);
assert( (buf=dc_decrypt_setup_file(context, s_em_setupcode, s_em_setupfile)) != NULL );
assert( dc_split_armored_data(buf, &headerline, &setupcodebegin, &preferencrypt, NULL) );
assert( headerline && strcmp(headerline, "-----BEGIN PGP PRIVATE KEY BLOCK-----")==0 );
assert( setupcodebegin==NULL );
assert( preferencrypt && strcmp(preferencrypt, "mutual")==0 );
free(buf);
}
if (dc_is_configured(context) )
{
char *setupcode = NULL, *setupfile = NULL;
assert( (setupcode=dc_create_setup_code(context)) != NULL );
assert( strlen(setupcode) == 44 );
assert( setupcode[4]=='-' && setupcode[9]=='-' && setupcode[14]=='-' && setupcode[19]=='-' && setupcode[24]=='-' && setupcode[29]=='-' && setupcode[34]=='-' && setupcode[39]=='-' );
assert( (setupfile=dc_render_setup_file(context, setupcode)) != NULL );
{
char *buf = dc_strdup(setupfile);
const char *headerline = NULL, *setupcodebegin = NULL;
assert( dc_split_armored_data(buf, &headerline, &setupcodebegin, NULL, NULL) );
assert( headerline && strcmp(headerline, "-----BEGIN PGP MESSAGE-----")==0 );
assert( setupcodebegin && strlen(setupcodebegin)==2 && strncmp(setupcodebegin, setupcode, 2)==0 );
free(buf);
}
{
char *payload = NULL;
const char *headerline = NULL;
assert( (payload=dc_decrypt_setup_file(context, setupcode, setupfile))!=NULL );
assert( dc_split_armored_data(payload, &headerline, NULL, NULL, NULL) );
assert( headerline && strcmp(headerline, "-----BEGIN PGP PRIVATE KEY BLOCK-----")==0 );
free(payload);
}
free(setupfile);
free(setupcode);
}
/* test end-to-end-encryption
**************************************************************************/
{
dc_key_t *bad_key = dc_key_new();
#define BAD_DATA_BYTES 4096
unsigned char bad_data[BAD_DATA_BYTES];
for( int i = 0; i < BAD_DATA_BYTES; i++ ) {
bad_data[i] = (unsigned char)(i&0xFF);
}
for( int j = 0; j < BAD_DATA_BYTES/40; j++ ) {
dc_key_set_from_binary(bad_key, &bad_data[j], BAD_DATA_BYTES/2 + j, (j&1)? DC_KEY_PUBLIC : DC_KEY_PRIVATE);
assert( !dc_pgp_is_valid_key(context, bad_key) );
}
dc_key_unref(bad_key);
}
{
dc_key_t *public_key = dc_key_new(), *private_key = dc_key_new();
dc_pgp_create_keypair(context, "foo@bar.de", public_key, private_key);
assert( dc_pgp_is_valid_key(context, public_key) );
assert( dc_pgp_is_valid_key(context, private_key) );
//{char *t1=dc_key_render_asc(public_key); printf("%s",t1);dc_write_file("/home/bpetersen/temp/stress-public.asc", t1,strlen(t1),mailbox);dc_write_file("/home/bpetersen/temp/stress-public.der", public_key->binary, public_key->bytes, mailbox);free(t1);}
//{char *t1=dc_key_render_asc(private_key);printf("%s",t1);dc_write_file("/home/bpetersen/temp/stress-private.asc",t1,strlen(t1),mailbox);dc_write_file("/home/bpetersen/temp/stress-private.der",private_key->binary,private_key->bytes,mailbox);free(t1);}
{
dc_key_t *test_key = dc_key_new();
assert( dc_pgp_split_key(context, private_key, test_key) );
//assert( dc_key_equals(public_key, test_key) );
dc_key_unref(test_key);
}
dc_key_t *public_key2 = dc_key_new(), *private_key2 = dc_key_new();
dc_pgp_create_keypair(context, "two@zwo.de", public_key2, private_key2);
assert( !dc_key_equals(public_key, public_key2) );
const char* original_text = "This is a test";
void *ctext_signed = NULL, *ctext_unsigned = NULL;
size_t ctext_signed_bytes = 0, ctext_unsigned_bytes, plain_bytes = 0;
{
dc_keyring_t* keyring = dc_keyring_new();
dc_keyring_add(keyring, public_key);
dc_keyring_add(keyring, public_key2);
int ok = dc_pgp_pk_encrypt(context, original_text, strlen(original_text), keyring, private_key, 1, (void**)&ctext_signed, &ctext_signed_bytes);
assert( ok && ctext_signed && ctext_signed_bytes>0 );
assert( strncmp((char*)ctext_signed, "-----BEGIN PGP MESSAGE-----", 27)==0 );
assert( ((char*)ctext_signed)[ctext_signed_bytes-1]!=0 ); /*armored strings are not null-terminated!*/
//{char* t3 = dc_null_terminate((char*)ctext,ctext_bytes);printf("\n%i ENCRYPTED BYTES: {\n%s\n}\n",(int)ctext_bytes,t3);free(t3);}
ok = dc_pgp_pk_encrypt(context, original_text, strlen(original_text), keyring, NULL, 1, (void**)&ctext_unsigned, &ctext_unsigned_bytes);
assert( ok && ctext_unsigned && ctext_unsigned_bytes>0 );
assert( strncmp((char*)ctext_unsigned, "-----BEGIN PGP MESSAGE-----", 27)==0 );
assert( ctext_unsigned_bytes < ctext_signed_bytes );
dc_keyring_unref(keyring);
}
{
dc_keyring_t* keyring = dc_keyring_new();
dc_keyring_add(keyring, private_key);
dc_keyring_t* public_keyring = dc_keyring_new();
dc_keyring_add(public_keyring, public_key);
dc_keyring_t* public_keyring2 = dc_keyring_new();
dc_keyring_add(public_keyring2, public_key2);
void* plain = NULL;
dc_hash_t valid_signatures;
dc_hash_init(&valid_signatures, DC_HASH_STRING, 1/*copy key*/);
int ok;
ok = dc_pgp_pk_decrypt(context, ctext_signed, ctext_signed_bytes, keyring, public_keyring/*for validate*/, 1, &plain, &plain_bytes, &valid_signatures);
assert( ok && plain && plain_bytes>0 );
assert( strncmp((char*)plain, original_text, strlen(original_text))==0 );
assert( dc_hash_cnt(&valid_signatures) == 1 );
free(plain); plain = NULL;
dc_hash_clear(&valid_signatures);
ok = dc_pgp_pk_decrypt(context, ctext_signed, ctext_signed_bytes, keyring, NULL/*for validate*/, 1, &plain, &plain_bytes, &valid_signatures);
assert( ok && plain && plain_bytes>0 );
assert( strncmp((char*)plain, original_text, strlen(original_text))==0 );
assert( dc_hash_cnt(&valid_signatures) == 0 );
free(plain); plain = NULL;
dc_hash_clear(&valid_signatures);
ok = dc_pgp_pk_decrypt(context, ctext_signed, ctext_signed_bytes, keyring, public_keyring2/*for validate*/, 1, &plain, &plain_bytes, &valid_signatures);
assert( ok && plain && plain_bytes>0 );
assert( strncmp((char*)plain, original_text, strlen(original_text))==0 );
assert( dc_hash_cnt(&valid_signatures) == 0 );
free(plain); plain = NULL;
dc_hash_clear(&valid_signatures);
dc_keyring_add(public_keyring2, public_key);
ok = dc_pgp_pk_decrypt(context, ctext_signed, ctext_signed_bytes, keyring, public_keyring2/*for validate*/, 1, &plain, &plain_bytes, &valid_signatures);
assert( ok && plain && plain_bytes>0 );
assert( strncmp((char*)plain, original_text, strlen(original_text))==0 );
assert( dc_hash_cnt(&valid_signatures) == 1 );
free(plain); plain = NULL;
dc_hash_clear(&valid_signatures);
ok = dc_pgp_pk_decrypt(context, ctext_unsigned, ctext_unsigned_bytes, keyring, public_keyring/*for validate*/, 1, &plain, &plain_bytes, &valid_signatures);
assert( ok && plain && plain_bytes>0 );
assert( strncmp((char*)plain, original_text, strlen(original_text))==0 );
// FIXME: assert( dc_hash_cnt(&valid_signatures) == 0 );
free(plain); plain = NULL;
dc_hash_clear(&valid_signatures);
dc_keyring_unref(keyring);
dc_keyring_unref(public_keyring);
dc_keyring_unref(public_keyring2);
}
{
dc_keyring_t* keyring = dc_keyring_new();
dc_keyring_add(keyring, private_key2);
dc_keyring_t* public_keyring = dc_keyring_new();
dc_keyring_add(public_keyring, public_key);
void* plain = NULL;
int ok = dc_pgp_pk_decrypt(context, ctext_signed, ctext_signed_bytes, keyring, public_keyring/*for validate*/, 1, &plain, &plain_bytes, NULL);
assert( ok && plain && plain_bytes>0 );
assert( plain_bytes == strlen(original_text) );
assert( strncmp(plain, original_text, plain_bytes)==0 );
free(plain);
dc_keyring_unref(keyring);
dc_keyring_unref(public_keyring);
}
free(ctext_signed);
free(ctext_unsigned);
dc_key_unref(public_key2);
dc_key_unref(private_key2);
dc_key_unref(public_key);
dc_key_unref(private_key);
}
/* test out-of-band verification
**************************************************************************/
{
char* fingerprint = dc_normalize_fingerprint(" 1234 567890 \n AbcD abcdef ABCDEF ");
assert( fingerprint );
assert( strcmp(fingerprint, "1234567890ABCDABCDEFABCDEF") == 0 );
free(fingerprint);
}
if (dc_is_configured(context))
{
char* qr = dc_get_securejoin_qr(context, 0);
assert( strlen(qr)>55 && strncmp(qr, "OPENPGP4FPR:", 12)==0 && strncmp(&qr[52], "#a=", 3)==0 );
dc_lot_t* res = dc_check_qr(context, qr);
assert( res );
assert( res->state == DC_QR_ASK_VERIFYCONTACT || res->state == DC_QR_FPR_MISMATCH || res->state == DC_QR_FPR_WITHOUT_ADDR );
dc_lot_unref(res);
free(qr);
res = dc_check_qr(context, "BEGIN:VCARD\nVERSION:3.0\nN:Last;First\nEMAIL;TYPE=INTERNET:stress@test.local\nEND:VCARD");
assert( res );
assert( res->state == DC_QR_ADDR );
assert( res->id != 0 );
dc_lot_unref(res);
}
}
Reference in a new issue View git blame Copy permalink