[thirdparty/systemd.git] / src / test / test-id128.c

/***
  This file is part of systemd.

  Copyright 2011 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <string.h>

#include "sd-daemon.h"
#include "sd-id128.h"

#include "alloc-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "id128-util.h"
#include "macro.h"
#include "string-util.h"
#include "util.h"

#define ID128_WALDI SD_ID128_MAKE(01, 02, 03, 04, 05, 06, 07, 08, 09, 0a, 0b, 0c, 0d, 0e, 0f, 10)
#define STR_WALDI "0102030405060708090a0b0c0d0e0f10"
#define UUID_WALDI "01020304-0506-0708-090a-0b0c0d0e0f10"

int main(int argc, char *argv[]) {
        sd_id128_t id, id2;
        char t[33], q[37];
        _cleanup_free_ char *b = NULL;
        _cleanup_close_ int fd = -1;

        assert_se(sd_id128_randomize(&id) == 0);
        printf("random: %s\n", sd_id128_to_string(id, t));

        assert_se(sd_id128_from_string(t, &id2) == 0);
        assert_se(sd_id128_equal(id, id2));

        if (sd_booted() > 0) {
                assert_se(sd_id128_get_machine(&id) == 0);
                printf("machine: %s\n", sd_id128_to_string(id, t));

                assert_se(sd_id128_get_boot(&id) == 0);
                printf("boot: %s\n", sd_id128_to_string(id, t));
        }

        printf("waldi: %s\n", sd_id128_to_string(ID128_WALDI, t));
        assert_se(streq(t, STR_WALDI));

        assert_se(asprintf(&b, SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)) == 32);
        printf("waldi2: %s\n", b);
        assert_se(streq(t, b));

        printf("waldi3: %s\n", id128_to_uuid_string(ID128_WALDI, q));
        assert_se(streq(q, UUID_WALDI));

        b = mfree(b);
        assert_se(asprintf(&b, ID128_UUID_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)) == 36);
        printf("waldi4: %s\n", b);
        assert_se(streq(q, b));

        assert_se(sd_id128_from_string(STR_WALDI, &id) >= 0);
        assert_se(sd_id128_equal(id, ID128_WALDI));

        assert_se(sd_id128_from_string(UUID_WALDI, &id) >= 0);
        assert_se(sd_id128_equal(id, ID128_WALDI));

        assert_se(sd_id128_from_string("", &id) < 0);
        assert_se(sd_id128_from_string("01020304-0506-0708-090a-0b0c0d0e0f101", &id) < 0);
        assert_se(sd_id128_from_string("01020304-0506-0708-090a-0b0c0d0e0f10-", &id) < 0);
        assert_se(sd_id128_from_string("01020304-0506-0708-090a0b0c0d0e0f10", &id) < 0);
        assert_se(sd_id128_from_string("010203040506-0708-090a-0b0c0d0e0f10", &id) < 0);

        assert_se(id128_is_valid(STR_WALDI));
        assert_se(id128_is_valid(UUID_WALDI));
        assert_se(!id128_is_valid(""));
        assert_se(!id128_is_valid("01020304-0506-0708-090a-0b0c0d0e0f101"));
        assert_se(!id128_is_valid("01020304-0506-0708-090a-0b0c0d0e0f10-"));
        assert_se(!id128_is_valid("01020304-0506-0708-090a0b0c0d0e0f10"));
        assert_se(!id128_is_valid("010203040506-0708-090a-0b0c0d0e0f10"));

        fd = open_tmpfile_unlinkable(NULL, O_RDWR|O_CLOEXEC);
        assert_se(fd >= 0);

        /* First, write as UUID */
        assert_se(sd_id128_randomize(&id) >= 0);
        assert_se(id128_write_fd(fd, ID128_UUID, id, false) >= 0);

        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(id128_read_fd(fd, ID128_PLAIN, &id2) == -EINVAL);

        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(id128_read_fd(fd, ID128_UUID, &id2) >= 0);
        assert_se(sd_id128_equal(id, id2));

        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(id128_read_fd(fd, ID128_ANY, &id2) >= 0);
        assert_se(sd_id128_equal(id, id2));

        /* Second, write as plain */
        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(ftruncate(fd, 0) >= 0);

        assert_se(sd_id128_randomize(&id) >= 0);
        assert_se(id128_write_fd(fd, ID128_PLAIN, id, false) >= 0);

        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(id128_read_fd(fd, ID128_UUID, &id2) == -EINVAL);

        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(id128_read_fd(fd, ID128_PLAIN, &id2) >= 0);
        assert_se(sd_id128_equal(id, id2));

        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(id128_read_fd(fd, ID128_ANY, &id2) >= 0);
        assert_se(sd_id128_equal(id, id2));

        /* Third, write plain without trailing newline */
        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(ftruncate(fd, 0) >= 0);

        assert_se(sd_id128_randomize(&id) >= 0);
        assert_se(write(fd, sd_id128_to_string(id, t), 32) == 32);

        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(id128_read_fd(fd, ID128_UUID, &id2) == -EINVAL);

        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(id128_read_fd(fd, ID128_PLAIN, &id2) >= 0);
        assert_se(sd_id128_equal(id, id2));

        /* Third, write UUID without trailing newline */
        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(ftruncate(fd, 0) >= 0);

        assert_se(sd_id128_randomize(&id) >= 0);
        assert_se(write(fd, id128_to_uuid_string(id, q), 36) == 36);

        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(id128_read_fd(fd, ID128_PLAIN, &id2) == -EINVAL);

        assert_se(lseek(fd, 0, SEEK_SET) == 0);
        assert_se(id128_read_fd(fd, ID128_UUID, &id2) >= 0);
        assert_se(sd_id128_equal(id, id2));

        assert_se(sd_id128_get_machine_app_specific(SD_ID128_MAKE(f0,3d,aa,eb,1c,33,4b,43,a7,32,17,29,44,bf,77,2e), &id) >= 0);
        assert_se(sd_id128_get_machine_app_specific(SD_ID128_MAKE(f0,3d,aa,eb,1c,33,4b,43,a7,32,17,29,44,bf,77,2e), &id2) >= 0);
        assert_se(sd_id128_equal(id, id2));
        assert_se(sd_id128_get_machine_app_specific(SD_ID128_MAKE(51,df,0b,4b,c3,b0,4c,97,80,e2,99,b9,8c,a3,73,b8), &id2) >= 0);
        assert_se(!sd_id128_equal(id, id2));

        return 0;
}
Commit	Line	Data
87d2c1ff LP	1	/***
	2	This file is part of systemd.
	3
	4	Copyright 2011 Lennart Poettering
	5
	6	systemd is free software; you can redistribute it and/or modify it
5430f7f2 LP	7	under the terms of the GNU Lesser General Public License as published by
5430f7f2 LP	8	the Free Software Foundation; either version 2.1 of the License, or
87d2c1ff LP	9	(at your option) any later version.
	10
	11	systemd is distributed in the hope that it will be useful, but
	12	WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
5430f7f2	14	Lesser General Public License for more details.
87d2c1ff	15
5430f7f2	16	You should have received a copy of the GNU Lesser General Public License
87d2c1ff LP	17	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	18	***/
	19
	20	#include <string.h>
	21
07630cea LP	22	#include "sd-daemon.h"
07630cea LP	23	#include "sd-id128.h"
81527be1	24
b5efdb8a	25	#include "alloc-util.h"
65548c58 LP	26	#include "fd-util.h"
	27	#include "fileio.h"
	28	#include "id128-util.h"
87d2c1ff	29	#include "macro.h"
07630cea LP	30	#include "string-util.h"
07630cea LP	31	#include "util.h"
87d2c1ff LP	32
87d2c1ff LP	33	#define ID128_WALDI SD_ID128_MAKE(01, 02, 03, 04, 05, 06, 07, 08, 09, 0a, 0b, 0c, 0d, 0e, 0f, 10)
aa96c6cb LP	34	#define STR_WALDI "0102030405060708090a0b0c0d0e0f10"
aa96c6cb LP	35	#define UUID_WALDI "01020304-0506-0708-090a-0b0c0d0e0f10"
87d2c1ff LP	36
	37	int main(int argc, char *argv[]) {
	38	sd_id128_t id, id2;
910fd145	39	char t[33], q[37];
aa96c6cb	40	_cleanup_free_ char *b = NULL;
65548c58	41	_cleanup_close_ int fd = -1;
87d2c1ff LP	42
	43	assert_se(sd_id128_randomize(&id) == 0);
	44	printf("random: %s\n", sd_id128_to_string(id, t));
	45
	46	assert_se(sd_id128_from_string(t, &id2) == 0);
	47	assert_se(sd_id128_equal(id, id2));
	48
143bfdaf HHPF	49	if (sd_booted() > 0) {
	50	assert_se(sd_id128_get_machine(&id) == 0);
	51	printf("machine: %s\n", sd_id128_to_string(id, t));
87d2c1ff	52
143bfdaf HHPF	53	assert_se(sd_id128_get_boot(&id) == 0);
	54	printf("boot: %s\n", sd_id128_to_string(id, t));
	55	}
87d2c1ff LP	56
87d2c1ff LP	57	printf("waldi: %s\n", sd_id128_to_string(ID128_WALDI, t));
aa96c6cb LP	58	assert_se(streq(t, STR_WALDI));
	59
	60	assert_se(asprintf(&b, SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)) == 32);
	61	printf("waldi2: %s\n", b);
	62	assert_se(streq(t, b));
	63
910fd145 LP	64	printf("waldi3: %s\n", id128_to_uuid_string(ID128_WALDI, q));
	65	assert_se(streq(q, UUID_WALDI));
	66
	67	b = mfree(b);
	68	assert_se(asprintf(&b, ID128_UUID_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)) == 36);
	69	printf("waldi4: %s\n", b);
	70	assert_se(streq(q, b));
	71
	72	assert_se(sd_id128_from_string(STR_WALDI, &id) >= 0);
	73	assert_se(sd_id128_equal(id, ID128_WALDI));
	74
aa96c6cb LP	75	assert_se(sd_id128_from_string(UUID_WALDI, &id) >= 0);
	76	assert_se(sd_id128_equal(id, ID128_WALDI));
	77
	78	assert_se(sd_id128_from_string("", &id) < 0);
	79	assert_se(sd_id128_from_string("01020304-0506-0708-090a-0b0c0d0e0f101", &id) < 0);
	80	assert_se(sd_id128_from_string("01020304-0506-0708-090a-0b0c0d0e0f10-", &id) < 0);
	81	assert_se(sd_id128_from_string("01020304-0506-0708-090a0b0c0d0e0f10", &id) < 0);
	82	assert_se(sd_id128_from_string("010203040506-0708-090a-0b0c0d0e0f10", &id) < 0);
	83
	84	assert_se(id128_is_valid(STR_WALDI));
	85	assert_se(id128_is_valid(UUID_WALDI));
	86	assert_se(!id128_is_valid(""));
	87	assert_se(!id128_is_valid("01020304-0506-0708-090a-0b0c0d0e0f101"));
	88	assert_se(!id128_is_valid("01020304-0506-0708-090a-0b0c0d0e0f10-"));
	89	assert_se(!id128_is_valid("01020304-0506-0708-090a0b0c0d0e0f10"));
	90	assert_se(!id128_is_valid("010203040506-0708-090a-0b0c0d0e0f10"));
eaff7bd8	91
65548c58 LP	92	fd = open_tmpfile_unlinkable(NULL, O_RDWR\|O_CLOEXEC);
	93	assert_se(fd >= 0);
	94
	95	/* First, write as UUID */
	96	assert_se(sd_id128_randomize(&id) >= 0);
	97	assert_se(id128_write_fd(fd, ID128_UUID, id, false) >= 0);
	98
	99	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	100	assert_se(id128_read_fd(fd, ID128_PLAIN, &id2) == -EINVAL);
	101
	102	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	103	assert_se(id128_read_fd(fd, ID128_UUID, &id2) >= 0);
	104	assert_se(sd_id128_equal(id, id2));
	105
	106	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	107	assert_se(id128_read_fd(fd, ID128_ANY, &id2) >= 0);
	108	assert_se(sd_id128_equal(id, id2));
	109
	110	/* Second, write as plain */
	111	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	112	assert_se(ftruncate(fd, 0) >= 0);
	113
	114	assert_se(sd_id128_randomize(&id) >= 0);
	115	assert_se(id128_write_fd(fd, ID128_PLAIN, id, false) >= 0);
	116
	117	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	118	assert_se(id128_read_fd(fd, ID128_UUID, &id2) == -EINVAL);
	119
	120	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	121	assert_se(id128_read_fd(fd, ID128_PLAIN, &id2) >= 0);
	122	assert_se(sd_id128_equal(id, id2));
	123
	124	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	125	assert_se(id128_read_fd(fd, ID128_ANY, &id2) >= 0);
	126	assert_se(sd_id128_equal(id, id2));
	127
	128	/* Third, write plain without trailing newline */
	129	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	130	assert_se(ftruncate(fd, 0) >= 0);
	131
	132	assert_se(sd_id128_randomize(&id) >= 0);
	133	assert_se(write(fd, sd_id128_to_string(id, t), 32) == 32);
	134
	135	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	136	assert_se(id128_read_fd(fd, ID128_UUID, &id2) == -EINVAL);
	137
	138	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	139	assert_se(id128_read_fd(fd, ID128_PLAIN, &id2) >= 0);
	140	assert_se(sd_id128_equal(id, id2));
	141
	142	/* Third, write UUID without trailing newline */
	143	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	144	assert_se(ftruncate(fd, 0) >= 0);
	145
	146	assert_se(sd_id128_randomize(&id) >= 0);
ba8868f5	147	assert_se(write(fd, id128_to_uuid_string(id, q), 36) == 36);
65548c58 LP	148
	149	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	150	assert_se(id128_read_fd(fd, ID128_PLAIN, &id2) == -EINVAL);
	151
	152	assert_se(lseek(fd, 0, SEEK_SET) == 0);
	153	assert_se(id128_read_fd(fd, ID128_UUID, &id2) >= 0);
	154	assert_se(sd_id128_equal(id, id2));
	155
70fc4f57 LP	156	assert_se(sd_id128_get_machine_app_specific(SD_ID128_MAKE(f0,3d,aa,eb,1c,33,4b,43,a7,32,17,29,44,bf,77,2e), &id) >= 0);
	157	assert_se(sd_id128_get_machine_app_specific(SD_ID128_MAKE(f0,3d,aa,eb,1c,33,4b,43,a7,32,17,29,44,bf,77,2e), &id2) >= 0);
	158	assert_se(sd_id128_equal(id, id2));
	159	assert_se(sd_id128_get_machine_app_specific(SD_ID128_MAKE(51,df,0b,4b,c3,b0,4c,97,80,e2,99,b9,8c,a3,73,b8), &id2) >= 0);
	160	assert_se(!sd_id128_equal(id, id2));
	161
87d2c1ff LP	162	return 0;
87d2c1ff LP	163	}