site - tilde.institute site files

about summary refs log tree commit diff stats

path: root/wiki/lib/plugins/authldap/lang/fa

diff options

Diffstat (limited to 'wiki/lib/plugins/authldap/lang/fa')

0 files changed, 0 insertions, 0 deletions

he previous revision' href='/danisanti/profani-tty/blame/src/xmpp_message.c?id=0b7a0531d08822985e5244fa4b8f5cfffc100454'>^

706af9a9 ^

3adc399d ^

b269ac97 ^

e8fc80f5 ^

b269ac97 ^

f9737251 ^

b269ac97 ^

9b177a9e ^

2b88e2f1 ^

0f01f30b ^

b269ac97 ^

a4cadf78 ^

0a57c4de ^

424f52c3 ^

0a57c4de ^

a40a0f51 ^

0a57c4de ^

0fb27dc4 ^

0a57c4de ^

9b55f2de ^

a4cadf78 ^

59a3a5fe ^

0a57c4de ^

fc5bfb7d ^

a4cadf78 ^

fc5bfb7d ^

5cec47c8 ^

4839093a ^

b269ac97 ^

0fb27dc4 ^

9b55f2de ^

a4cadf78 ^

0fb27dc4 ^

a2726b6a ^

1ae5d9f1 ^

a2726b6a ^

1ae5d9f1 ^

a2726b6a ^

d01ba725 ^

a2726b6a ^

5cec47c8 ^

46cd09cc ^

06482fda ^

d39e48ba ^

8de6a7bf ^

1eaa2c15 ^

8de6a7bf ^

2c94ee5a ^

a2726b6a ^

1ae5d9f1 ^

83ed9ba2 ^

a2726b6a ^

d39e48ba ^

a2726b6a ^

d39e48ba ^

83ed9ba2 ^

d39e48ba ^

83ed9ba2 ^

3640900c ^

a2726b6a ^

3640900c ^

a2726b6a ^

3640900c ^

d01ba725 ^

3640900c ^

1f96e14c ^

3640900c ^

c66d3c63 ^

a2726b6a ^

c66d3c63 ^

83ed9ba2 ^

a2726b6a ^

83ed9ba2 ^

d39e48ba ^

b14b7114 ^

a2726b6a ^

d39e48ba ^

e656bdb8 ^

d39e48ba ^

e656bdb8 ^

b14b7114 ^

d39e48ba ^

23e886ed ^

e656bdb8 ^

23e886ed ^

57fb10f0 ^

23e886ed ^

6c3e6a52 ^

23e886ed ^

56efb1a2 ^

46a00317 ^

b14b7114 ^

06482fda ^

46cd09cc ^

5cec47c8 ^

6be5b51a ^

b14b7114 ^

a2726b6a ^

b14b7114 ^

d39e48ba ^

b14b7114 ^

a2726b6a ^

b14b7114 ^

d9cfa2e4 ^

b14b7114 ^

d39e48ba ^

b14b7114 ^

a2726b6a ^

b14b7114 ^

d9cfa2e4 ^

b14b7114 ^

d39e48ba ^

b14b7114 ^

a2726b6a ^

b14b7114 ^

d39e48ba ^

b14b7114 ^

a2726b6a ^

b14b7114 ^

d9cfa2e4 ^

b14b7114 ^

d39e48ba ^

a2726b6a ^

896e6c4e ^

2f7317cc ^

896e6c4e ^

b1343cd3 ^

a2726b6a ^

b1343cd3 ^

b1bd1ecc ^

b1343cd3 ^

896e6c4e ^

1435c7ae ^

896e6c4e ^

46a00317 ^

6be5b51a ^

a2726b6a ^

6be5b51a ^

1ae5d9f1 ^

d39e48ba ^

0f01f30b ^

b269ac97 ^

5cec47c8 ^

2601fc55 ^

5cec47c8 ^

aabe3aff ^

f60864f8 ^

a2726b6a ^

d39e48ba ^

1ae5d9f1 ^

a2726b6a ^

1ae5d9f1 ^

a2726b6a ^

1ae5d9f1 ^

65b3f82c ^

1ae5d9f1 ^

a2726b6a ^

44d16e91 ^

a2726b6a ^

44d16e91 ^

180ec2b4 ^

44d16e91 ^

f71de61b ^

8852db03 ^

f16d56a1 ^

44d16e91 ^

a4b53550 ^

44d16e91 ^

498b75af ^

3524a53c ^

44d16e91 ^

a2726b6a ^

44d16e91 ^

a2726b6a ^

180ec2b4 ^

44d16e91 ^

f71de61b ^

8852db03 ^

f16d56a1 ^

44d16e91 ^

1ae5d9f1 ^

b8c80594 ^

a2726b6a ^

1ae5d9f1 ^

a2726b6a ^

1ae5d9f1 ^

f60864f8 ^

c8a6bdb3 ^

a2726b6a ^

9b991ae0 ^

a2726b6a ^

9b991ae0 ^

1a85448b ^

a2726b6a ^

e45afd5c ^

a2726b6a ^

45048e3a ^

e45afd5c ^

9b991ae0 ^

1b0ce852 ^

a978bb12 ^

e45afd5c ^

11181100 ^

d39e48ba ^

e45afd5c ^

c8a6bdb3 ^

a2726b6a ^

e45afd5c ^

a2726b6a ^

e45afd5c ^

1a85448b ^

a2726b6a ^

eb5cb7b2 ^

a2726b6a ^

9b177a9e ^

a2726b6a ^

eb5cb7b2 ^

b5359214 ^

a2726b6a ^

eb5cb7b2 ^

45048e3a ^

4792984f ^

a2726b6a ^

eb5cb7b2 ^

a2726b6a ^

eb5cb7b2 ^

45048e3a ^

eb5cb7b2 ^

5305a3e3 ^

45048e3a ^

eb5cb7b2 ^

2af5c151 ^

eb5cb7b2 ^

2c94ee5a ^

45048e3a ^

eb5cb7b2 ^

78beccee ^

9b991ae0 ^

a978bb12 ^

78beccee ^

2ff6873c ^

11b6e1bf ^

d39e48ba ^

2ff6873c ^

57c75644 ^

2ff6873c ^

2c94ee5a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

8de6a7bf ^

a2726b6a ^

2c94ee5a ^

1a85448b ^

b5359214 ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

1eaa2c15 ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

449c7ce2 ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

2c94ee5a ^

2c94ee5a ^

8de6a7bf ^

2c94ee5a ^

c8a6bdb3 ^

a2726b6a ^

2ff6873c ^

a2726b6a ^

2ff6873c ^

1a85448b ^

a2726b6a ^

9b991ae0 ^

a2726b6a ^

45048e3a ^

78beccee ^

9b991ae0 ^

a978bb12 ^

78beccee ^

b269ac97 ^

11b6e1bf ^

d39e48ba ^

b269ac97 ^

57c75644 ^

b269ac97 ^

0f01f30b ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

1a85448b ^

a2726b6a ^

a9d55dec ^

53640f6e ^

a9d55dec ^

e69f9475 ^

a9d55dec ^

53640f6e ^

a9d55dec ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

a2726b6a ^

de06cd39 ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

a2726b6a ^

714add20 ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

a2726b6a ^

0fb27dc4 ^

a2726b6a ^

904904d7 ^

a2726b6a ^

904904d7 ^

91ee289c ^

904904d7 ^

d871efdc ^

36ce21fc ^

0fb27dc4 ^

11b6e1bf ^

0fb27dc4 ^

a0a4fd04 ^

a2726b6a ^

0f01f30b ^

a2726b6a ^

45048e3a ^

a2726b6a ^

45048e3a ^

1b0ce852 ^

d39e48ba ^

90ac69be ^

a0a4fd04 ^

90ac69be ^

e69f9475 ^

a2726b6a ^

7584ddaa ^

a2726b6a ^

45048e3a ^

a2726b6a ^

e69f9475 ^

45048e3a ^

1b0ce852 ^

4ec005e4 ^

d39e48ba ^

7584ddaa ^

e69f9475 ^

7584ddaa ^

9d94ac5c ^

a2726b6a ^

ea267e20 ^

a2726b6a ^

ea267e20 ^

d39e48ba ^

ea267e20 ^

9d94ac5c ^

a2726b6a ^

81020e6d ^

a2726b6a ^

fac2b2cf ^

a2726b6a ^

1917d4c0 ^

fac2b2cf ^

81020e6d ^

d39e48ba ^

81020e6d ^

9d94ac5c ^

a2726b6a ^

0f01f30b ^

a2726b6a ^

0f01f30b ^

a2726b6a ^

d39e48ba ^

0f01f30b ^

0f01f30b ^

9d94ac5c ^

a2726b6a ^

0f01f30b ^

a2726b6a ^

d39e48ba ^

0f01f30b ^

0f01f30b ^

9d94ac5c ^

a2726b6a ^

0f01f30b ^

a2726b6a ^

0f01f30b ^

d39e48ba ^

0f01f30b ^

0f01f30b ^

9d94ac5c ^

a2726b6a ^

0f01f30b ^

a2726b6a ^

d39e48ba ^

0f01f30b ^

0f01f30b ^

d39e48ba ^

a2726b6a ^

292ae567 ^

a2726b6a ^

ddc64755 ^

24c3eff4 ^

e9959d5d ^

27293ebb ^

a2726b6a ^

1a300ce7 ^

a2726b6a ^

ddc64755 ^

e9959d5d ^

1a300ce7 ^

1a300ce7 ^

ddc64755 ^

e9959d5d ^

10a3a3a6 ^

292ae567 ^

ddc64755 ^

e9959d5d ^

1a300ce7 ^

27293ebb ^

1a300ce7 ^

292ae567 ^

01181780 ^

01181780 ^

3b3c9bf4 ^

b5359214 ^

8df5e999 ^

8df5e999 ^

3b3c9bf4 ^

01181780 ^

292ae567 ^

e9959d5d ^

292ae567 ^

d39e48ba ^

a2726b6a ^

b6095ca9 ^

a2726b6a ^

b6095ca9 ^

f21a99ea ^

ddc64755 ^

b6095ca9 ^

d39e48ba ^

b6095ca9 ^

a2726b6a ^

ddc64755 ^

d39e48ba ^

ddc64755 ^

b6095ca9 ^

a2726b6a ^

ddc64755 ^

d39e48ba ^

ddc64755 ^

b6095ca9 ^

b5359214 ^

ddc64755 ^

d39e48ba ^

ddc64755 ^

a2726b6a ^

b6095ca9 ^

a2726b6a ^

ddc64755 ^

71c2be59 ^

a2726b6a ^

ddc64755 ^

ddc64755 ^

d8a92f93 ^

d8a92f93 ^

d39e48ba ^

a2726b6a ^

d8a92f93 ^

a2726b6a ^

d8a92f93 ^

96b22872 ^

ca9c946d ^

b6095ca9 ^

96b22872 ^

b6095ca9 ^

b5359214 ^

96b22872 ^

b6095ca9 ^

96b22872 ^

96b22872 ^

d8a92f93 ^

d39e48ba ^

a2726b6a ^

d8a92f93 ^

a2726b6a ^

d8a92f93 ^

ddc64755 ^

d8a92f93 ^

d39e48ba ^

d8a92f93 ^

c84cb17b ^

a2726b6a ^

236c8544 ^

d39e48ba ^

b6095ca9 ^

236c8544 ^

b6095ca9 ^

4839093a ^

d39e48ba ^

a2726b6a ^

0f01f30b ^

a2726b6a ^

e69f9475 ^

a2726b6a ^

d01ba725 ^

22362424 ^

b5359214 ^

d01ba725 ^

22362424 ^

0f01f30b ^

bc6f8ceb ^

a2726b6a ^

ddc64755 ^

9cfe5ec7 ^

180ec2b4 ^

44d16e91 ^

bc6f8ceb ^

d39e48ba ^

bc6f8ceb ^

0f01f30b ^

180ec2b4 ^

a2726b6a ^

44d16e91 ^

4839093a ^

d39e48ba ^

236c8544 ^

44d16e91 ^

236c8544 ^

d39e48ba ^

bc6f8ceb ^

0f01f30b ^

180ec2b4 ^

d39e48ba ^

0f01f30b ^

180ec2b4 ^

d39e48ba ^

0f01f30b ^

a2726b6a ^

b5359214 ^

180ec2b4 ^

3524a53c ^

7cd1be36 ^

9cfe5ec7 ^

ac96a695 ^

7cd1be36 ^

3884a4d3 ^

9cfe5ec7 ^

f71de61b ^

44d16e91 ^

a2726b6a ^

7cd1be36 ^

a2726b6a ^

7cd1be36 ^

a444137e ^

4e1ffa6b ^

a3897abb ^

44d16e91 ^

3bb3cc62 ^

a3897abb ^

a444137e ^

183eeca6 ^

a444137e ^

236c8544 ^

8a948824 ^

180ec2b4 ^

61f66966 ^

180ec2b4 ^

61f66966 ^

779c2efc ^

e9c5c197 ^

8a948824 ^

56836fb7 ^

8a948824 ^

44d16e91 ^

236c8544 ^

44d16e91 ^

0f01f30b ^

a444137e ^

44d16e91 ^

0f01f30b ^

3350139e ^

a2726b6a ^

78beccee ^

a2726b6a ^

39ff3996 ^

a2726b6a ^

0410dd90 ^

78beccee ^

a2726b6a ^

78beccee ^

24c3eff4 ^

78beccee ^

d39e48ba ^

78beccee ^

d39e48ba ^

a2726b6a ^

5a90e286 ^

a2726b6a ^

e396e863 ^

099260a4 ^

e396e863 ^

5a90e286 ^

e396e863 ^

5a90e286 ^

e396e863 ^

5a90e286 ^

b5359214 ^

d01ba725 ^

099260a4 ^

e396e863 ^

e396e863 ^

5a90e286 ^

3350139e ^

a2726b6a ^

f25f90b3 ^

a2726b6a ^

f25f90b3 ^

a2726b6a ^

f25f90b3 ^

a2726b6a ^

b2a02424 ^

f25f90b3 ^

a2726b6a ^

d2dc4405 ^

b5359214 ^

d2dc4405 ^

d2dc4405 ^

f25f90b3 ^

44d16e91 ^

a2726b6a ^

530c060d ^

44d16e91 ^

a2726b6a ^

3524a53c ^

44d16e91 ^

a2726b6a ^

ee87e5b0 ^

180ec2b4 ^

ee87e5b0 ^

44d16e91 ^

ed1d49bf ^

a2726b6a ^

ed1d49bf ^

44d16e91 ^

530c060d ^

44d16e91 ^

c0e8f722 ^

19902e8e ^

183eeca6 ^

19902e8e ^

44d16e91 ^

530c060d ^

d1d0ad8d ^

44d16e91 ^

530c060d ^

f504a021 ^

44d16e91 ^

530c060d ^

896e6c4e ^

a2726b6a ^

a0c872ed ^

a2726b6a ^

948d63d8 ^

896e6c4e ^

948d63d8 ^

896e6c4e ^

fca59a31 ^

fca59a31 ^

896e6c4e ^

fca59a31 ^

2f7317cc ^

948d63d8 ^

896e6c4e ^

948d63d8 ^

a0c872ed ^

a2726b6a ^

948d63d8 ^

896e6c4e ^

948d63d8 ^

a2726b6a ^

44d16e91 ^

948d63d8 ^

896e6c4e ^

948d63d8 ^

a0c872ed ^

91e8a89b ^

896e6c4e ^

a0c872ed ^

d39e48ba ^

d01ba725 ^

0f01f30b ^

7151792b ^

a2726b6a ^

7151792b ^

d39e48ba ^

4898ed10 ^

a2726b6a ^

f3b8cc40 ^

b5359214 ^

8a6d256f ^

0f01f30b ^

9f2f54b2 ^

2a7a389c ^

d39e48ba ^

530c060d ^

0f01f30b ^

ac940c2c ^

a2726b6a ^

0412ec96 ^

b5359214 ^

896e6c4e ^

7553676b ^

896e6c4e ^

0412ec96 ^

dd566d8d ^

f16d56a1 ^

a2726b6a ^

f16d56a1 ^

8852db03 ^

8852db03 ^

17b1b431 ^

8852db03 ^

0412ec96 ^

a2726b6a ^

f16d56a1 ^

a2726b6a ^

f16d56a1 ^

1435c7ae ^

d1d0ad8d ^

44d16e91 ^

810ea322 ^

530c060d ^

44d16e91 ^

0412ec96 ^

44d16e91 ^

0f01f30b ^

a2726b6a ^

44d16e91 ^

810ea322 ^

a2726b6a ^

0412ec96 ^

a2726b6a ^

2c94ee5a ^

44d16e91 ^

896e6c4e ^

a2726b6a ^

896e6c4e ^

aecbeff8 ^

896e6c4e ^

44d16e91 ^

896e6c4e ^

530c060d ^

c16871d1 ^

c66d3c63 ^

e41ae21b ^

2dc0cc48 ^

c66d3c63 ^

0f01f30b ^

530c060d ^

44d16e91 ^

ced5a8c2 ^

2dc0cc48 ^

10190b5f ^

a2726b6a ^

10190b5f ^

a2726b6a ^

0412ec96 ^

8de6a7bf ^

17b1b431 ^

d01ba725 ^

66eeccf4 ^

d01ba725 ^

2a011e69 ^

d01ba725 ^

2dc0cc48 ^

2a011e69 ^

2a011e69 ^

2a011e69 ^

66eeccf4 ^

2a011e69 ^

11382a8b ^

6173e015 ^

66eeccf4 ^

11382a8b ^

2a011e69 ^

2c94ee5a ^

8de6a7bf ^

2c94ee5a ^

38273fef ^

a2726b6a ^

38273fef ^

17b1b431 ^

38273fef ^

a2726b6a ^

38273fef ^

8852db03 ^

d01ba725 ^

1435c7ae ^

a2726b6a ^

1435c7ae ^

38273fef ^

d0397f3d ^

a2726b6a ^

728cb55b ^

a2726b6a ^

728cb55b ^

a2726b6a ^

728cb55b ^

a2726b6a ^

d0397f3d ^

a2726b6a ^

d0397f3d ^

a2726b6a ^

d0397f3d ^

7b34f720 ^

2bacd43a ^

d0397f3d ^

7b34f720 ^

d0397f3d ^

31ab43ea ^

d0397f3d ^

06f300a4 ^

f71de61b ^

4d7a496a ^

a2726b6a ^

4d7a496a ^

06f300a4 ^

f71de61b ^

a2726b6a ^

f71de61b ^

06f300a4 ^

f71de61b ^

8c50b63e ^

4d7a496a ^

8c50b63e ^

a2726b6a ^

4d7a496a ^

8c50b63e ^

a2726b6a ^

2a4d1b84 ^

8c50b63e ^

f71de61b ^

06f300a4 ^

a2726b6a ^

06f300a4 ^

2c94ee5a ^

8de6a7bf ^

3350139e ^

1eaa2c15 ^

10190b5f ^

10190b5f ^

c9e6a89a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

a2726b6a ^

2c94ee5a ^

8de6a7bf ^

ec6f9df4 ^

46cd09cc ^

06482fda ^

b5359214 ^

06482fda ^

06482fda ^

35
36

39
40
41

42
43

44
45

50
51

55
56

68
69

70
71

72
73

75
76

107
108

120
121

155
156
157

170
171
172

173
174

201
202
203

207
208

214
215

221
222
223

227
228

233
234
235

244
245

246
247

258
259
260

261
262
263

275
276

277
278

299
300
301

313
314

316
317

318
319

332
333

335
336

339
340

345
346
347

420
421

428
429

444
445
446

463
464

468
469

477
478

487
488

491
492

497
498

508
509

516
517

518
519

533
534

540
541
542

544
545

550
551

552
553
554

556
557
558

560
561

579
580

581
582

589
590

593
594

603
604

611
612

615
616

623
624
625

632
633

636
637
638

643
644
645

660
661

672
673

674
675

688
689

690
691

716
717

736
737

740
741

748
749

750
751

755
756

760
761

772
773

774
775

779
780

783
784
785

787
788

790
791

804
805
806

815
816

820
821

824
825

829
830

834
835

839
840

843
844

855
856

875
876
877

879
880

884
885

888
889

892
893

897
898
899

908
909
910

917
918

928
929

930
931
932

934
935

947
948

968
969
970

978
979

983
984

990
991

995
996

997
998

999
1000

1030
1031

1034
1035

1040
1041

1046
1047

1051
1052

1076
1077

1078
1079

1084
1085

1087
1088
1089

1090
1091

1093
1094

1101
1102
1103

1130
1131

1134
1135
1136

1138
1139

1149
1150

1152
1153

1175
1176

1179
1180

1186
1187

1191
1192

1199
1200
1201

1206
1207

1209
1210

1224
1225
1226

1229
1230

1250
1251
1252

1256
1257

1258
1259

1260
1261

1275
1276
1277

1291
1292

1293
1294
1295

1303
1304

1306
1307

1309
1310

1313
1314

1319
1320

1322
1323

1325
1326

1336
1337

1339
1340

1356
1357

1361
1362
1363

1364
1365

1368
1369

1371
1372
1373

1375
1376
1377

1378
1379

1448
1449

1450
1451

1463
1464
1465

1470
1471

1475
1476

1514
1515
1516

1517
1518

1520
1521
1522

1535
1536

1539
1540

1562
1563

1569
1570
1571

1590
1591
1592

1593
1594

1604
1605
1606

1608
1609

1610
1611

1612
1613

1626
1627
1628

1632
1633

1642
1643
1644

1665
1666

1668
1669
1670

1672
1673
1674

1683
1684

1686
1687

1689
1690
1691

/*
 * message.c
 * vim: expandtab:ts=4:sts=4:sw=4
 *
 * Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
 * Copyright (C) 2019 - 2023 Michael Vetter <jubalh@iodoru.org>
 *
 * This file is part of Profanity.
 *
 * Profanity is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Profanity 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Profanity.  If not, see <https://www.gnu.org/licenses/>.
 *
 * In addition, as a special exception, the copyright holders give permission to
 * link the code of portions of this program with the OpenSSL library under
 * certain conditions as described in each individual source file, and
 * distribute linked combinations including the two.
 *
 * You must obey the GNU General Public License in all respects for all of the
 * code used other than OpenSSL. If you modify file(s) with this exception, you
 * may extend this exception to your version of the file(s), but you are not
 * obligated to do so. If you do not wish to do so, delete this exception
 * statement from your version. If you delete this exception statement from all
 * source files in the program, then also delete it here.
 *
 */

#include "config.h"

#include <stdlib.h>
#include <string.h>

#include <strophe.h>

#include "profanity.h"
#include "log.h"
#include "config/preferences.h"
#include "event/server_events.h"
#include "pgp/gpg.h"
#include "pgp/ox.h"
#include "plugins/plugins.h"
#include "ui/ui.h"
#include "ui/window_list.h"
#include "xmpp/chat_session.h"
#include "xmpp/muc.h"
#include "xmpp/session.h"
#include "xmpp/message.h"
#include "xmpp/roster.h"
#include "xmpp/roster_list.h"
#include "xmpp/stanza.h"
#include "xmpp/connection.h"
#include "xmpp/xmpp.h"
#include "xmpp/form.h"
#include "xmpp/iq.h"

#ifdef HAVE_OMEMO
#include "xmpp/omemo.h"
#include "omemo/omemo.h"
#endif

typedef struct p_message_handle_t
{
    ProfMessageCallback func;
    ProfMessageFreeCallback free_func;
    void* userdata;
} ProfMessageHandler;

static int _message_handler(xmpp_conn_t* const conn, xmpp_stanza_t* const stanza, void* const userdata);
static void _handle_error(xmpp_stanza_t* const stanza);
static void _handle_groupchat(xmpp_stanza_t* const stanza);
static void _handle_muc_user(xmpp_stanza_t* const stanza);
static void _handle_muc_private_message(xmpp_stanza_t* const stanza);
static void _handle_conference(xmpp_stanza_t* const stanza);
static void _handle_captcha(xmpp_stanza_t* const stanza);
static void _handle_receipt_received(xmpp_stanza_t* const stanza);
static void _handle_chat(xmpp_stanza_t* const stanza, gboolean is_mam, gboolean is_carbon, const char* result_id, GDateTime* timestamp);
static void _handle_ox_chat(xmpp_stanza_t* const stanza, ProfMessage* message, gboolean is_mam);
static xmpp_stanza_t* _handle_carbons(xmpp_stanza_t* const stanza);
static void _send_message_stanza(xmpp_stanza_t* const stanza);
static gboolean _handle_mam(xmpp_stanza_t* const stanza);
static void _handle_pubsub(xmpp_stanza_t* const stanza, xmpp_stanza_t* const event);
static gboolean _handle_form(xmpp_stanza_t* const stanza);
static gboolean _handle_jingle_message(xmpp_stanza_t* const stanza);
static gboolean _should_ignore_based_on_silence(xmpp_stanza_t* const stanza);

#ifdef HAVE_LIBGPGME
static xmpp_stanza_t* _ox_openpgp_signcrypt(xmpp_ctx_t* ctx, const char* const to, const char* const text);
#endif // HAVE_LIBGPGME

static GHashTable* pubsub_event_handlers;

static gboolean
_handled_by_plugin(xmpp_stanza_t* const stanza)
{
    char* text;
    size_t text_size;

    xmpp_stanza_to_text(stanza, &text, &text_size);
    gboolean cont = plugins_on_message_stanza_receive(text);
    xmpp_free(connection_get_ctx(), text);

    return !cont;
}

static void
_handle_headline(xmpp_stanza_t* const stanza)
{
    xmpp_stanza_t* body = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BODY);
    if (body) {
        char* text = xmpp_stanza_get_text(body);
        if (text) {
            cons_show("Headline: %s", text);
            xmpp_free(connection_get_ctx(), text);
        }
    }
}

static void
_handle_chat_states(xmpp_stanza_t* const stanza, Jid* const jid)
{
    gboolean gone = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_GONE) != NULL;
    gboolean typing = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_COMPOSING) != NULL;
    gboolean paused = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_PAUSED) != NULL;
    gboolean inactive = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_INACTIVE) != NULL;
    if (gone) {
        sv_ev_gone(jid->barejid, jid->resourcepart);
    } else if (typing) {
        sv_ev_typing(jid->barejid, jid->resourcepart);
    } else if (paused) {
        sv_ev_paused(jid->barejid, jid->resourcepart);
    } else if (inactive) {
        sv_ev_inactive(jid->barejid, jid->resourcepart);
    } else if (stanza_contains_chat_state(stanza)) {
        sv_ev_activity(jid->barejid, jid->resourcepart, TRUE);
    } else {
        sv_ev_activity(jid->barejid, jid->resourcepart, FALSE);
    }
}

static int
_message_handler(xmpp_conn_t* const conn, xmpp_stanza_t* const stanza, void* const userdata)
{
    log_debug("Message stanza handler fired");

    if (_handled_by_plugin(stanza)) {
        return 1;
    }

    // type according to RFC 6121
    const char* type = xmpp_stanza_get_type(stanza);

    if (type && g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
        _handle_error(stanza);
    } else if (type && g_strcmp0(type, STANZA_TYPE_GROUPCHAT) == 0) {
        // XEP-0045: Multi-User Chat
        _handle_groupchat(stanza);

    } else if (type && g_strcmp0(type, STANZA_TYPE_HEADLINE) == 0) {
        xmpp_stanza_t* event = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB_EVENT);
        // TODO: do we want to handle all pubsub here or should additionally check for STANZA_NS_MOOD?
        if (event) {
            _handle_pubsub(stanza, event);
            return 1;
        } else {
            _handle_headline(stanza);
        }
    } else if (type == NULL || g_strcmp0(type, STANZA_TYPE_CHAT) == 0 || g_strcmp0(type, STANZA_TYPE_NORMAL) == 0) {
        // type: chat, normal (==NULL)

        // ignore all messages from JIDs that are not in roster, if 'silence' is set
        if (_should_ignore_based_on_silence(stanza)) {
            return 1;
        }

        // XEP-0353: Jingle Message Initiation
        if (_handle_jingle_message(stanza)) {
            return 1;
        }

        // XEP-0045: Multi-User Chat 8.6 Voice Requests
        if (_handle_form(stanza)) {
            return 1;
        }

        // XEP-0313: Message Archive Management
        if (_handle_mam(stanza)) {
            return 1;
        }

        // XEP-0045: Multi-User Chat - invites - presence
        xmpp_stanza_t* mucuser = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);
        if (mucuser) {
            _handle_muc_user(stanza);
        }

        // XEP-0249: Direct MUC Invitations
        xmpp_stanza_t* conference = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_CONFERENCE);
        if (conference) {
            _handle_conference(stanza);
            return 1;
        }

        // XEP-0158: CAPTCHA Forms
        xmpp_stanza_t* captcha = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_CAPTCHA);
        if (captcha) {
            _handle_captcha(stanza);
            return 1;
        }

        // XEP-0184: Message Delivery Receipts
        xmpp_stanza_t* receipts = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_RECEIPTS);
        if (receipts) {
            _handle_receipt_received(stanza);
        }

        // XEP-0060: Publish-Subscribe
        xmpp_stanza_t* event = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_PUBSUB_EVENT);
        if (event) {
            _handle_pubsub(stanza, event);
            return 1;
        }

        xmpp_stanza_t* msg_stanza = stanza;
        gboolean is_carbon = FALSE;

        // XEP-0280: Message Carbons
        // Only allow `<sent xmlns='urn:xmpp:carbons:2'>` and `<received xmlns='urn:xmpp:carbons:2'>` carbons
        // Thus ignoring `<private xmlns="urn:xmpp:carbons:2"/>`
        xmpp_stanza_t* carbons = xmpp_stanza_get_child_by_name_and_ns(stanza, STANZA_NAME_SENT, STANZA_NS_CARBONS);
        if (!carbons) {
            carbons = xmpp_stanza_get_child_by_name_and_ns(stanza, STANZA_NAME_RECEIVED, STANZA_NS_CARBONS);
        }

        if (carbons) {

            // carbon must come from ourselves
            char* mybarejid = connection_get_barejid();
            const char* const stanza_from = xmpp_stanza_get_from(stanza);

            if (stanza_from) {
                if (g_strcmp0(mybarejid, stanza_from) != 0) {
                    log_warning("Invalid carbon received, from: %s", stanza_from);
                    msg_stanza = NULL;
                } else {
                    is_carbon = TRUE;
                    // returns NULL if it was a carbon that was invalid, so that we dont parse later
                    msg_stanza = _handle_carbons(carbons);
                }
            }

            free(mybarejid);
        }

        if (msg_stanza) {
            _handle_chat(msg_stanza, FALSE, is_carbon, NULL, NULL);
        }
    } else {
        // none of the allowed types
        char* text;
        size_t text_size;

        xmpp_stanza_to_text(stanza, &text, &text_size);
        log_info("Received <message> with invalid 'type': %s", text);

        xmpp_free(connection_get_ctx(), text);
    }

    return 1;
}

void
message_muc_submit_voice_approve(ProfConfWin* confwin)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();
    xmpp_stanza_t* message = stanza_create_approve_voice(ctx, NULL, confwin->roomjid, NULL, confwin->form);

    _send_message_stanza(message);
    xmpp_stanza_release(message);
}

static gboolean
_handle_form(xmpp_stanza_t* const stanza)
{
    xmpp_stanza_t* result = xmpp_stanza_get_child_by_name_and_ns(stanza, STANZA_NAME_X, STANZA_NS_DATA);
    if (!result) {
        return FALSE;
    }

    const char* const stanza_from = xmpp_stanza_get_from(stanza);
    if (!stanza_from) {
        return FALSE;
    }

    DataForm* form = form_create(result);
    ProfConfWin* confwin = (ProfConfWin*)wins_new_config(stanza_from, form, message_muc_submit_voice_approve, NULL, NULL);
    confwin_handle_configuration(confwin, form);

    return TRUE;
}

void
message_handlers_init(void)
{
    xmpp_conn_t* const conn = connection_get_conn();
    xmpp_ctx_t* const ctx = connection_get_ctx();
    xmpp_handler_add(conn, _message_handler, NULL, STANZA_NAME_MESSAGE, NULL, ctx);

    if (pubsub_event_handlers) {
        GList* keys = g_hash_table_get_keys(pubsub_event_handlers);
        GList* curr = keys;
        while (curr) {
            ProfMessageHandler* handler = g_hash_table_lookup(pubsub_event_handlers, curr->data);
            if (handler->free_func && handler->userdata) {
                handler->free_func(handler->userdata);
            }
            curr = g_list_next(curr);
        }
        g_list_free(keys);
        g_hash_table_destroy(pubsub_event_handlers);
    }

    pubsub_event_handlers = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
}

ProfMessage*
message_init(void)
{
    ProfMessage* message = malloc(sizeof(ProfMessage));

    message->from_jid = NULL;
    message->to_jid = NULL;
    message->id = NULL;
    message->originid = NULL;
    message->stanzaid = NULL;
    message->replace_id = NULL;
    message->body = NULL;
    message->encrypted = NULL;
    message->plain = NULL;
    message->enc = PROF_MSG_ENC_NONE;
    message->timestamp = NULL;
    message->trusted = true;
    message->type = PROF_MSG_TYPE_UNINITIALIZED;

    return message;
}

void
message_free(ProfMessage* message)
{
    xmpp_ctx_t* ctx = connection_get_ctx();
    if (message->from_jid) {
        jid_destroy(message->from_jid);
    }

    if (message->to_jid) {
        jid_destroy(message->to_jid);
    }

    if (message->id) {
        xmpp_free(ctx, message->id);
    }

    if (message->originid) {
        xmpp_free(ctx, message->originid);
    }

    if (message->stanzaid) {
        xmpp_free(ctx, message->stanzaid);
    }

    if (message->replace_id) {
        xmpp_free(ctx, message->replace_id);
    }

    if (message->body) {
        xmpp_free(ctx, message->body);
    }

    if (message->encrypted) {
        xmpp_free(ctx, message->encrypted);
    }

    if (message->plain) {
        free(message->plain);
    }

    if (message->timestamp) {
        g_date_time_unref(message->timestamp);
    }

    free(message);
}

void
message_handlers_clear(void)
{
    if (pubsub_event_handlers) {
        g_hash_table_remove_all(pubsub_event_handlers);
    }
}

void
message_pubsub_event_handler_add(const char* const node, ProfMessageCallback func, ProfMessageFreeCallback free_func, void* userdata)
{
    ProfMessageHandler* handler = malloc(sizeof(ProfMessageHandler));
    handler->func = func;
    handler->free_func = free_func;
    handler->userdata = userdata;

    g_hash_table_insert(pubsub_event_handlers, strdup(node), handler);
}

char*
message_send_chat(const char* const barejid, const char* const msg, const char* const oob_url, gboolean request_receipt, const char* const replace_id)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();

    const char* state = chat_session_get_state(barejid);
    char* jid = chat_session_get_jid(barejid);
    char* id = connection_create_stanza_id();

    xmpp_stanza_t* message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
    xmpp_message_set_body(message, msg);
    free(jid);

    if (state) {
        stanza_attach_state(ctx, message, state);
    }

    if (oob_url) {
        stanza_attach_x_oob_url(ctx, message, oob_url);
    }

    if (request_receipt) {
        stanza_attach_receipt_request(ctx, message);
    }

    if (replace_id) {
        stanza_attach_correction(ctx, message, replace_id);
    }

    _send_message_stanza(message);
    xmpp_stanza_release(message);

    return id;
}

char*
message_send_chat_pgp(const char* const barejid, const char* const msg, gboolean request_receipt, const char* const replace_id)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();

    const char* state = chat_session_get_state(barejid);
    char* jid = chat_session_get_jid(barejid);
    char* id = connection_create_stanza_id();

    xmpp_stanza_t* message = NULL;
#ifdef HAVE_LIBGPGME
    char* account_name = session_get_account_name();
    ProfAccount* account = accounts_get_account(account_name);
    if (account->pgp_keyid) {
        auto_jid Jid* jidp = jid_create(jid);
        char* encrypted = p_gpg_encrypt(jidp->barejid, msg, account->pgp_keyid);
        if (encrypted) {
            message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
            xmpp_message_set_body(message, "This message is encrypted (XEP-0027).");
            xmpp_stanza_t* x = xmpp_stanza_new(ctx);
            xmpp_stanza_set_name(x, STANZA_NAME_X);
            xmpp_stanza_set_ns(x, STANZA_NS_ENCRYPTED);
            xmpp_stanza_t* enc_st = xmpp_stanza_new(ctx);
            xmpp_stanza_set_text(enc_st, encrypted);
            xmpp_stanza_add_child(x, enc_st);
            xmpp_stanza_release(enc_st);
            xmpp_stanza_add_child(message, x);
            xmpp_stanza_release(x);
            free(encrypted);
        } else {
            message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
            xmpp_message_set_body(message, msg);
        }
    } else {
        message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
        xmpp_message_set_body(message, msg);
    }
    account_free(account);
#else
    // ?
    message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
    xmpp_message_set_body(message, msg);
#endif
    free(jid);

    if (state) {
        stanza_attach_state(ctx, message, state);
    }

    if (request_receipt) {
        stanza_attach_receipt_request(ctx, message);
    }

    if (replace_id) {
        stanza_attach_correction(ctx, message, replace_id);
    }

    _send_message_stanza(message);
    xmpp_stanza_release(message);

    return id;
}

// XEP-0373: OpenPGP for XMPP
char*
message_send_chat_ox(const char* const barejid, const char* const msg, gboolean request_receipt, const char* const replace_id)
{
#ifdef HAVE_LIBGPGME
    xmpp_ctx_t* const ctx = connection_get_ctx();

    const char* state = chat_session_get_state(barejid);
    auto_char char* jid = chat_session_get_jid(barejid);
    char* id = connection_create_stanza_id();

    xmpp_stanza_t* message = NULL;

    char* account_name = session_get_account_name();
    ProfAccount* account = accounts_get_account(account_name);

    message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
    xmpp_message_set_body(message, "This message is encrypted (XEP-0373: OpenPGP for XMPP).");

    xmpp_stanza_t* openpgp = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(openpgp, STANZA_NAME_OPENPGP);
    xmpp_stanza_set_ns(openpgp, STANZA_NS_OPENPGP_0);

    xmpp_stanza_t* signcrypt = _ox_openpgp_signcrypt(ctx, barejid, msg);
    char* c;
    size_t s;
    xmpp_stanza_to_text(signcrypt, &c, &s);
    char* signcrypt_e = p_ox_gpg_signcrypt(account->jid, barejid, c);
    if (signcrypt_e == NULL) {
        cons_show("Unable to send OX message. Check log file and profanity-ox-setup man page for details.");
        log_error("Message not signcrypted.");
        return NULL;
    }
    // BASE64_OPENPGP_MESSAGE
    xmpp_stanza_t* base64_openpgp_message = xmpp_stanza_new(ctx);
    xmpp_stanza_set_text(base64_openpgp_message, signcrypt_e);
    xmpp_stanza_add_child(openpgp, base64_openpgp_message);
    xmpp_stanza_add_child(message, openpgp);

    xmpp_stanza_to_text(message, &c, &s);

    account_free(account);

    if (state) {
        stanza_attach_state(ctx, message, state);
    }

    if (request_receipt) {
        stanza_attach_receipt_request(ctx, message);
    }

    if (replace_id) {
        stanza_attach_correction(ctx, message, replace_id);
    }

    _send_message_stanza(message);
    xmpp_stanza_release(message);

    return id;
#endif // HAVE_LIBGPGME
    return NULL;
}

char*
message_send_chat_otr(const char* const barejid, const char* const msg, gboolean request_receipt, const char* const replace_id)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();

    const char* state = chat_session_get_state(barejid);
    char* jid = chat_session_get_jid(barejid);
    char* id = connection_create_stanza_id();

    xmpp_stanza_t* message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, barejid, id);
    xmpp_message_set_body(message, msg);

    free(jid);

    if (state) {
        stanza_attach_state(ctx, message, state);
    }

    if (request_receipt) {
        stanza_attach_receipt_request(ctx, message);
    }

    if (replace_id) {
        stanza_attach_correction(ctx, message, replace_id);
    }

    _send_message_stanza(message);
    xmpp_stanza_release(message);

    return id;
}

#ifdef HAVE_OMEMO
char*
message_send_chat_omemo(const char* const jid, uint32_t sid, GList* keys,
                        const unsigned char* const iv, size_t iv_len,
                        const unsigned char* const ciphertext, size_t ciphertext_len,
                        gboolean request_receipt, gboolean muc, const char* const replace_id)
{
    const char* state = chat_session_get_state(jid);
    xmpp_ctx_t* const ctx = connection_get_ctx();
    char* id;
    xmpp_stanza_t* message;
    if (muc) {
        id = connection_create_stanza_id();
        message = xmpp_message_new(ctx, STANZA_TYPE_GROUPCHAT, jid, id);
        stanza_attach_origin_id(ctx, message, id);
    } else {
        id = connection_create_stanza_id();
        message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
    }

    xmpp_stanza_t* encrypted = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(encrypted, "encrypted");
    xmpp_stanza_set_ns(encrypted, STANZA_NS_OMEMO);

    xmpp_stanza_t* header = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(header, "header");
    char* sid_text = g_strdup_printf("%d", sid);
    log_debug("[OMEMO] Sending from device sid %s", sid_text);
    xmpp_stanza_set_attribute(header, "sid", sid_text);
    g_free(sid_text);

    GList* key_iter;
    for (key_iter = keys; key_iter != NULL; key_iter = key_iter->next) {
        omemo_key_t* key = (omemo_key_t*)key_iter->data;

        xmpp_stanza_t* key_stanza = xmpp_stanza_new(ctx);
        xmpp_stanza_set_name(key_stanza, "key");
        char* rid = g_strdup_printf("%d", key->device_id);
        log_debug("[OMEMO] Sending to device rid %s", STR_MAYBE_NULL(rid));
        xmpp_stanza_set_attribute(key_stanza, "rid", rid);
        g_free(rid);
        if (key->prekey) {
            xmpp_stanza_set_attribute(key_stanza, "prekey", "true");
        }

        gchar* key_raw = g_base64_encode(key->data, key->length);
        xmpp_stanza_t* key_text = xmpp_stanza_new(ctx);
        xmpp_stanza_set_text(key_text, key_raw);
        g_free(key_raw);

        xmpp_stanza_add_child(key_stanza, key_text);
        xmpp_stanza_add_child(header, key_stanza);
        xmpp_stanza_release(key_text);
        xmpp_stanza_release(key_stanza);
    }

    xmpp_stanza_t* iv_stanza = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(iv_stanza, "iv");

    gchar* iv_raw = g_base64_encode(iv, iv_len);
    xmpp_stanza_t* iv_text = xmpp_stanza_new(ctx);
    xmpp_stanza_set_text(iv_text, iv_raw);
    g_free(iv_raw);

    xmpp_stanza_add_child(iv_stanza, iv_text);
    xmpp_stanza_add_child(header, iv_stanza);
    xmpp_stanza_release(iv_text);
    xmpp_stanza_release(iv_stanza);

    xmpp_stanza_add_child(encrypted, header);
    xmpp_stanza_release(header);

    xmpp_stanza_t* payload = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(payload, "payload");

    gchar* ciphertext_raw = g_base64_encode(ciphertext, ciphertext_len);
    xmpp_stanza_t* payload_text = xmpp_stanza_new(ctx);
    xmpp_stanza_set_text(payload_text, ciphertext_raw);
    g_free(ciphertext_raw);

    xmpp_stanza_add_child(payload, payload_text);
    xmpp_stanza_add_child(encrypted, payload);
    xmpp_stanza_release(payload_text);
    xmpp_stanza_release(payload);

    xmpp_stanza_add_child(message, encrypted);
    xmpp_stanza_release(encrypted);

    xmpp_stanza_t* body = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(body, "body");
    xmpp_stanza_t* body_text = xmpp_stanza_new(ctx);
    xmpp_stanza_set_text(body_text, "You received a message encrypted with OMEMO but your client doesn't support OMEMO.");
    xmpp_stanza_add_child(body, body_text);
    xmpp_stanza_release(body_text);
    xmpp_stanza_add_child(message, body);
    xmpp_stanza_release(body);

    if (state) {
        stanza_attach_state(ctx, message, state);
    }

    stanza_attach_hints_store(ctx, message);

    if (request_receipt) {
        stanza_attach_receipt_request(ctx, message);
    }

    if (replace_id) {
        stanza_attach_correction(ctx, message, replace_id);
    }

    _send_message_stanza(message);
    xmpp_stanza_release(message);

    return id;
}
#endif

char*
message_send_private(const char* const fulljid, const char* const msg, const char* const oob_url)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();
    char* id = connection_create_stanza_id();

    xmpp_stanza_t* message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, fulljid, id);
    xmpp_message_set_body(message, msg);

    if (oob_url) {
        stanza_attach_x_oob_url(ctx, message, oob_url);
    }

    _send_message_stanza(message);
    xmpp_stanza_release(message);

    return id;
}

char*
message_send_groupchat(const char* const roomjid, const char* const msg, const char* const oob_url, const char* const replace_id)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();
    char* id = connection_create_stanza_id();

    xmpp_stanza_t* message = xmpp_message_new(ctx, STANZA_TYPE_GROUPCHAT, roomjid, id);
    stanza_attach_origin_id(ctx, message, id);
    xmpp_message_set_body(message, msg);

    if (oob_url) {
        stanza_attach_x_oob_url(ctx, message, oob_url);
    }

    if (replace_id) {
        stanza_attach_correction(ctx, message, replace_id);
    }

    _send_message_stanza(message);
    xmpp_stanza_release(message);

    return id;
}

void
message_send_groupchat_subject(const char* const roomjid, const char* const subject)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();
    xmpp_stanza_t* message = stanza_create_room_subject_message(ctx, roomjid, subject);

    _send_message_stanza(message);
    xmpp_stanza_release(message);
}

void
message_send_invite(const char* const roomjid, const char* const contact,
                    const char* const reason)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();
    xmpp_stanza_t* stanza;

    muc_member_type_t member_type = muc_member_type(roomjid);
    if (member_type == MUC_MEMBER_TYPE_PUBLIC) {
        log_debug("Sending direct invite to %s, for %s", contact, roomjid);
        char* password = muc_password(roomjid);
        stanza = stanza_create_invite(ctx, roomjid, contact, reason, password);
    } else {
        log_debug("Sending mediated invite to %s, for %s", contact, roomjid);
        stanza = stanza_create_mediated_invite(ctx, roomjid, contact, reason);
    }

    _send_message_stanza(stanza);
    xmpp_stanza_release(stanza);
}

void
message_send_composing(const char* const jid)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();

    xmpp_stanza_t* stanza = stanza_create_chat_state(ctx, jid, STANZA_NAME_COMPOSING);
    _send_message_stanza(stanza);
    xmpp_stanza_release(stanza);
}

void
message_send_paused(const char* const jid)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();
    xmpp_stanza_t* stanza = stanza_create_chat_state(ctx, jid, STANZA_NAME_PAUSED);
    _send_message_stanza(stanza);
    xmpp_stanza_release(stanza);
}

void
message_send_inactive(const char* const jid)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();
    xmpp_stanza_t* stanza = stanza_create_chat_state(ctx, jid, STANZA_NAME_INACTIVE);

    _send_message_stanza(stanza);
    xmpp_stanza_release(stanza);
}

void
message_send_gone(const char* const jid)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();
    xmpp_stanza_t* stanza = stanza_create_chat_state(ctx, jid, STANZA_NAME_GONE);
    _send_message_stanza(stanza);
    xmpp_stanza_release(stanza);
}

static void
_handle_error(xmpp_stanza_t* const stanza)
{
    const char* id = xmpp_stanza_get_id(stanza);
    const char* jid = xmpp_stanza_get_from(stanza);
    xmpp_stanza_t* error_stanza = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_ERROR);
    const char* type = NULL;
    if (error_stanza) {
        type = xmpp_stanza_get_type(error_stanza);
    }

    // stanza_get_error never returns NULL
    char* err_msg = stanza_get_error_message(stanza);

    GString* log_msg = g_string_new("message stanza error received");
    if (id) {
        g_string_append(log_msg, " id=");
        g_string_append(log_msg, id);
    }
    if (jid) {
        g_string_append(log_msg, " from=");
        g_string_append(log_msg, jid);
    }
    if (type) {
        g_string_append(log_msg, " type=");
        g_string_append(log_msg, type);
    }
    g_string_append(log_msg, " error=");
    g_string_append(log_msg, err_msg);

    log_info(log_msg->str);

    g_string_free(log_msg, TRUE);

    if (!jid) {
        ui_handle_error(err_msg);
    } else {
        if (type && (strcmp(type, "cancel") == 0)) {
            auto_jid Jid* jidp = jid_create(jid);
            if (jidp) {
                chat_session_remove(jidp->barejid);
            }
        }
        ui_handle_recipient_error(jid, err_msg);
    }

    free(err_msg);
}

static void
_handle_muc_user(xmpp_stanza_t* const stanza)
{
    xmpp_ctx_t* ctx = connection_get_ctx();
    xmpp_stanza_t* xns_muc_user = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);
    const char* room = xmpp_stanza_get_from(stanza);

    if (!xns_muc_user) {
        return;
    }

    if (!room) {
        log_warning("Message received with no from attribute, ignoring");
        return;
    }

    // XEP-0045
    xmpp_stanza_t* invite = xmpp_stanza_get_child_by_name(xns_muc_user, STANZA_NAME_INVITE);
    if (!invite) {
        return;
    }

    const char* invitor_jid = xmpp_stanza_get_from(invite);
    if (!invitor_jid) {
        log_warning("Chat room invite received with no from attribute");
        return;
    }

    auto_jid Jid* jidp = jid_create(invitor_jid);
    if (!jidp) {
        return;
    }
    char* invitor = jidp->barejid;

    char* reason = NULL;
    xmpp_stanza_t* reason_st = xmpp_stanza_get_child_by_name(invite, STANZA_NAME_REASON);
    if (reason_st) {
        reason = xmpp_stanza_get_text(reason_st);
    }

    char* password = NULL;
    xmpp_stanza_t* password_st = xmpp_stanza_get_child_by_name(xns_muc_user, STANZA_NAME_PASSWORD);
    if (password_st) {
        password = xmpp_stanza_get_text(password_st);
    }

    sv_ev_room_invite(INVITE_MEDIATED, invitor, room, reason, password);
    if (reason) {
        xmpp_free(ctx, reason);
    }
    if (password) {
        xmpp_free(ctx, password);
    }
}

static void
_handle_conference(xmpp_stanza_t* const stanza)
{
    xmpp_stanza_t* xns_conference = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_CONFERENCE);

    if (xns_conference) {
        // XEP-0249
        const char* room = xmpp_stanza_get_attribute(xns_conference, STANZA_ATTR_JID);
        if (!room) {
            return;
        }

        const char* from = xmpp_stanza_get_from(stanza);
        if (!from) {
            log_warning("Message received with no from attribute, ignoring");
            return;
        }

        auto_jid Jid* jidp = jid_create(from);
        if (!jidp) {
            return;
        }

        // reason and password are both optional
        const char* reason = xmpp_stanza_get_attribute(xns_conference, STANZA_ATTR_REASON);
        const char* password = xmpp_stanza_get_attribute(xns_conference, STANZA_ATTR_PASSWORD);

        sv_ev_room_invite(INVITE_DIRECT, jidp->barejid, room, reason, password);
    }
}

static void
_handle_captcha(xmpp_stanza_t* const stanza)
{
    xmpp_ctx_t* ctx = connection_get_ctx();
    const char* from = xmpp_stanza_get_from(stanza);

    if (!from) {
        log_warning("Message received with no from attribute, ignoring");
        return;
    }

    // XEP-0158
    char* message = xmpp_message_get_body(stanza);
    if (!message) {
        return;
    }

    sv_ev_room_broadcast(from, message);
    xmpp_free(ctx, message);
}

// Handle changes to muc configuration
static int
_room_config_handler(xmpp_stanza_t* const stanza, void* const userdata)
{
    const char* from = xmpp_stanza_get_from(stanza);
    xmpp_stanza_t* query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
    EntityCapabilities* capabilities = stanza_create_caps_from_query_element(query);

    // Update window name
    ProfMucWin* win = wins_get_muc(from);
    if (win != NULL) {
        free(win->room_name);
        win->room_name = strdup(capabilities->identity->name);

        // Update features
        muc_set_features(from, capabilities->features);
    }
    caps_destroy(capabilities);

    return 0;
}

static void
_handle_groupchat(xmpp_stanza_t* const stanza)
{
    xmpp_ctx_t* ctx = connection_get_ctx();

    const char* room_jid = xmpp_stanza_get_from(stanza);
    if (!room_jid) {
        return;
    }
    auto_jid Jid* from_jid = jid_create(room_jid);
    if (!from_jid) {
        return;
    }

    // handle room subject
    xmpp_stanza_t* subject = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_SUBJECT);
    if (subject) {
        // subject_text is optional, can be NULL
        char* subject_text = xmpp_stanza_get_text(subject);
        sv_ev_room_subject(from_jid->barejid, from_jid->resourcepart, subject_text);
        xmpp_free(ctx, subject_text);

        return;
    }

    // handle room broadcasts
    if (!from_jid->resourcepart) {
        char* broadcast;
        broadcast = xmpp_message_get_body(stanza);
        if (!broadcast) {
            xmpp_stanza_t* x = xmpp_stanza_get_child_by_name(stanza, "x");

            if (x) {
                xmpp_stanza_t* status = xmpp_stanza_get_child_by_name(x, "status");

                if (status) {
                    const char* code = xmpp_stanza_get_attribute(status, "code");

                    if (code) {
                        // If configuration change notification send disco info to get updated info of the muc
                        char* disqo_info_id = connection_create_stanza_id();
                        xmpp_stanza_t* iq = stanza_create_disco_info_iq(ctx, disqo_info_id, room_jid, NULL);
                        iq_id_handler_add(disqo_info_id, _room_config_handler, NULL, NULL);
                        free(disqo_info_id);
                        iq_send_stanza(iq);
                        xmpp_stanza_release(iq);

                        return;
                    }
                }
            }

            return;
        }

        sv_ev_room_broadcast(room_jid, broadcast);
        xmpp_free(ctx, broadcast);

        return;
    }

    if (!jid_is_valid_room_form(from_jid)) {
        log_error("Invalid room JID: %s", from_jid->str);
        return;
    }

    // room not active in profanity
    if (!muc_active(from_jid->barejid)) {
        log_error("Message received for inactive chat room: %s", from_jid->str);
        return;
    }

    ProfMessage* message = message_init();
    jid_ref(from_jid);
    message->from_jid = from_jid;
    message->type = PROF_MSG_TYPE_MUC;

    const char* id = xmpp_stanza_get_id(stanza);
    if (id) {
        message->id = strdup(id);
    }

    char* stanzaid = NULL;
    xmpp_stanza_t* stanzaidst = xmpp_stanza_get_child_by_name_and_ns(stanza, STANZA_NAME_STANZA_ID, STANZA_NS_STABLE_ID);
    if (stanzaidst) {
        stanzaid = (char*)xmpp_stanza_get_attribute(stanzaidst, STANZA_ATTR_ID);
        if (stanzaid) {
            message->stanzaid = strdup(stanzaid);
        }
    }

    xmpp_stanza_t* origin = xmpp_stanza_get_child_by_name_and_ns(stanza, STANZA_NAME_ORIGIN_ID, STANZA_NS_STABLE_ID);
    if (origin) {
        char* originid = (char*)xmpp_stanza_get_attribute(origin, STANZA_ATTR_ID);
        if (originid) {
            message->originid = strdup(originid);
        }
    }

    xmpp_stanza_t* replace_id_stanza = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_LAST_MESSAGE_CORRECTION);
    if (replace_id_stanza) {
        const char* replace_id = xmpp_stanza_get_id(replace_id_stanza);
        if (replace_id) {
            message->replace_id = strdup(replace_id);
        }
    }

    message->body = xmpp_message_get_body(stanza);

    // check omemo encryption
#ifdef HAVE_OMEMO
    message->plain = omemo_receive_message(stanza, &message->trusted);
    if (message->plain != NULL) {
        message->enc = PROF_MSG_ENC_OMEMO;
    }
#endif

    if (!message->plain && !message->body) {
        log_info("Message received without body for room: %s", from_jid->str);
        goto out;
    } else if (!message->plain) {
        message->plain = strdup(message->body);
    }

    // determine if the notifications happened whilst offline (MUC history)
    message->timestamp = stanza_get_delay_from(stanza, from_jid->barejid);
    if (message->timestamp == NULL) {
        // checking the domainpart is a workaround for some prosody versions (gh#1190)
        message->timestamp = stanza_get_delay_from(stanza, from_jid->domainpart);
    }

    bool is_muc_history = FALSE;
    if (message->timestamp != NULL) {
        is_muc_history = TRUE;
        g_date_time_unref(message->timestamp);
        message->timestamp = NULL;
    }

    // we want to display the oldest delay
    message->timestamp = stanza_get_oldest_delay(stanza);

    // now this has nothing to do with MUC history
    // it's just setting the time to the received time so upon displaying we can use this time
    // for example in win_println_incoming_muc_msg()
    if (!message->timestamp) {
        message->timestamp = g_date_time_new_now_local();
    }

    if (is_muc_history) {
        sv_ev_room_history(message);
    } else {
        sv_ev_room_message(message);
    }

out:
    message_free(message);
}

static void
_message_send_receipt(const char* const fulljid, const char* const message_id)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();

    char* id = connection_create_stanza_id();
    xmpp_stanza_t* message = xmpp_message_new(ctx, NULL, fulljid, id);
    free(id);

    xmpp_stanza_t* receipt = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(receipt, "received");
    xmpp_stanza_set_ns(receipt, STANZA_NS_RECEIPTS);
    xmpp_stanza_set_id(receipt, message_id);

    xmpp_stanza_add_child(message, receipt);
    xmpp_stanza_release(receipt);

    _send_message_stanza(message);
    xmpp_stanza_release(message);
}

static void
_handle_receipt_received(xmpp_stanza_t* const stanza)
{
    xmpp_stanza_t* receipt = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_RECEIPTS);
    if (receipt) {
        const char* name = xmpp_stanza_get_name(receipt);
        if ((name == NULL) || (g_strcmp0(name, "received") != 0)) {
            return;
        }

        const char* id = xmpp_stanza_get_id(receipt);
        if (!id) {
            return;
        }

        const char* fulljid = xmpp_stanza_get_from(stanza);
        if (!fulljid) {
            return;
        }

        auto_jid Jid* jidp = jid_create(fulljid);
        if (!jidp) {
            return;
        }

        sv_ev_message_receipt(jidp->barejid, id);
    }
}

static void
_receipt_request_handler(xmpp_stanza_t* const stanza)
{
    if (!prefs_get_boolean(PREF_RECEIPTS_SEND)) {
        return;
    }

    const char* id = xmpp_stanza_get_id(stanza);
    if (!id) {
        return;
    }

    xmpp_stanza_t* receipts = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_RECEIPTS);
    if (!receipts) {
        return;
    }

    const char* receipts_name = xmpp_stanza_get_name(receipts);
    if ((receipts_name == NULL) || (g_strcmp0(receipts_name, "request") != 0)) {
        return;
    }

    const gchar* from = xmpp_stanza_get_from(stanza);
    if (from) {
        auto_jid Jid* jid = jid_create(from);
        if (jid) {
            _message_send_receipt(jid->fulljid, id);
        }
    }
}

static void
_handle_muc_private_message(xmpp_stanza_t* const stanza)
{
    // standard chat message, use jid without resource
    ProfMessage* message = message_init();
    message->type = PROF_MSG_TYPE_MUCPM;

    const gchar* from = xmpp_stanza_get_from(stanza);
    if (!from) {
        goto out;
    }

    message->from_jid = jid_create(from);
    if (!message->from_jid) {
        goto out;
    }

    // message stanza id
    const char* id = xmpp_stanza_get_id(stanza);
    if (id) {
        message->id = strdup(id);
    }

    // check omemo encryption
#ifdef HAVE_OMEMO
    message->plain = omemo_receive_message(stanza, &message->trusted);
    if (message->plain != NULL) {
        message->enc = PROF_MSG_ENC_OMEMO;
    }
#endif

    message->timestamp = stanza_get_delay(stanza);
    message->body = xmpp_message_get_body(stanza);

    if (!message->plain && !message->body) {
        log_info("Message received without body from: %s", message->from_jid->str);
        goto out;
    } else if (!message->plain) {
        message->plain = strdup(message->body);
    }

    if (message->timestamp) {
        sv_ev_delayed_private_message(message);
    } else {
        message->timestamp = g_date_time_new_now_local();

        sv_ev_incoming_private_message(message);
    }

out:
    message_free(message);
}

static xmpp_stanza_t*
_handle_carbons(xmpp_stanza_t* const stanza)
{
    const char* name = xmpp_stanza_get_name(stanza);
    if (!name) {
        log_error("Unable to retrieve stanza name for Carbon");
        return NULL;
    }

    /* TODO: private shouldn't arrive at the client, should it?
    if (g_strcmp0(name, "private") == 0) {
        log_info("Carbon received with private element.");
    }
    */

    if ((g_strcmp0(name, STANZA_NAME_RECEIVED) != 0) && (g_strcmp0(name, STANZA_NAME_SENT) != 0)) {
        log_warning("Carbon received with unrecognised stanza name: %s", name);
        return NULL;
    }

    xmpp_stanza_t* forwarded = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_FORWARD);
    if (!forwarded) {
        log_warning("Carbon received with no forwarded element");
        return NULL;
    }

    xmpp_stanza_t* message_stanza = xmpp_stanza_get_child_by_name(forwarded, STANZA_NAME_MESSAGE);
    if (!message_stanza) {
        log_warning("Carbon received with no message element");
        return NULL;
    }

    // Eliminate duplicate messages in chat with oneself when another client is sending a message
    char* bare_from = xmpp_jid_bare(connection_get_ctx(), xmpp_stanza_get_from(message_stanza));
    if (g_strcmp0(bare_from, xmpp_stanza_get_to(message_stanza)) == 0) {
        free(bare_from);
        return NULL;
    }
    free(bare_from);

    return message_stanza;
}

static void
_handle_chat(xmpp_stanza_t* const stanza, gboolean is_mam, gboolean is_carbon, const char* result_id, GDateTime* timestamp)
{
    // some clients send the mucuser namespace with private messages
    // if the namespace exists, and the stanza contains a body element, assume its a private message
    // otherwise exit the handler
    xmpp_stanza_t* mucuser = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);
    xmpp_stanza_t* body = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BODY);
    if (mucuser && body == NULL) {
        return;
    }

    const gchar* from = xmpp_stanza_get_from(stanza);
    if (!from) {
        return;
    }
    auto_jid Jid* jid = jid_create(from);
    if (!jid) {
        return;
    }

    // private message from chat room use full jid (room/nick)
    if (muc_active(jid->barejid)) {
        _handle_muc_private_message(stanza);
        return;
    }

    // standard chat message, use jid without resource
    ProfMessage* message = message_init();
    message->is_mam = is_mam;
    jid_ref(jid);
    message->from_jid = jid;
    const gchar* to = xmpp_stanza_get_to(stanza);
    if (to) {
        message->to_jid = jid_create(to);
    } else if (is_carbon) {
        // happens when receive a carbon of a self sent message
        // really? maybe some servers do this, but it's not required.
        message->to_jid = jid_create(from);
    }

    if (mucuser) {
        message->type = PROF_MSG_TYPE_MUCPM;
    } else {
        message->type = PROF_MSG_TYPE_CHAT;
    }

    // message stanza id
    const char* id = xmpp_stanza_get_id(stanza);
    if (id) {
        message->id = strdup(id);
    }

    if (is_mam) {
        // MAM has XEP-0359 stanza-id as <result id="">
        if (result_id) {
            message->stanzaid = strdup(result_id);
        } else {
            log_warning("MAM received with no result id");
        }
    } else {
        // live messages use XEP-0359 <stanza-id>
        char* stanzaid = NULL;
        xmpp_stanza_t* stanzaidst = xmpp_stanza_get_child_by_name_and_ns(stanza, STANZA_NAME_STANZA_ID, STANZA_NS_STABLE_ID);
        if (stanzaidst) {
            stanzaid = (char*)xmpp_stanza_get_attribute(stanzaidst, STANZA_ATTR_ID);
            if (stanzaid) {
                message->stanzaid = strdup(stanzaid);
            }
        }
    }

    // replace id for XEP-0308: Last Message Correction
    xmpp_stanza_t* replace_id_stanza = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_LAST_MESSAGE_CORRECTION);
    if (replace_id_stanza) {
        const char* replace_id = xmpp_stanza_get_id(replace_id_stanza);
        if (replace_id) {
            message->replace_id = strdup(replace_id);
        }
    }

    if (timestamp) {
        // timestamp provided outside like in a <forwarded> by MAM
        message->timestamp = timestamp;
    } else {
        // timestamp in the message stanza or use time of receival (now)
        message->timestamp = stanza_get_delay(stanza);
        if (!message->timestamp) {
            message->timestamp = g_date_time_new_now_local();
        }
    }

    if (body) {
        message->body = xmpp_stanza_get_text(body);
    }

#ifdef HAVE_OMEMO
    // check omemo encryption
    message->plain = omemo_receive_message(stanza, &message->trusted);
    if (message->plain != NULL) {
        message->enc = PROF_MSG_ENC_OMEMO;
    }
#endif

    xmpp_stanza_t* encrypted = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_ENCRYPTED);
    if (encrypted) {
        message->encrypted = xmpp_stanza_get_text(encrypted);
    }

    xmpp_stanza_t* ox = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_OPENPGP_0);
    if (ox) {
        _handle_ox_chat(stanza, message, FALSE);
    }

    if (message->plain || message->body || message->encrypted) {
        if (is_carbon) {
            char* mybarejid = connection_get_barejid();

            // if we are the recipient, treat as standard incoming message
            if (g_strcmp0(mybarejid, message->to_jid->barejid) == 0) {
                sv_ev_incoming_carbon(message);
                // else treat as a sent message
            } else {
                sv_ev_outgoing_carbon(message);
            }

            free(mybarejid);
        } else {
            sv_ev_incoming_message(message);
            _receipt_request_handler(stanza);
        }
    }

    // 0085 works only with resource
    if (jid->resourcepart) {
        // XEP-0085: Chat Stase Notifications
        _handle_chat_states(stanza, jid);
    }

    message_free(message);
}

static void
_handle_ox_chat(xmpp_stanza_t* const stanza, ProfMessage* message, gboolean is_mam)
{
    message->enc = PROF_MSG_ENC_OX;

#ifdef HAVE_LIBGPGME
    xmpp_stanza_t* ox = xmpp_stanza_get_child_by_name_and_ns(stanza, "openpgp", STANZA_NS_OPENPGP_0);
    if (ox) {
        gchar* decrypted = p_ox_gpg_decrypt(xmpp_stanza_get_text(ox));
        if (decrypted) {
            xmpp_stanza_t* decrypted_stanza = xmpp_stanza_new_from_string(connection_get_ctx(), decrypted);
            if (decrypted_stanza) {
                xmpp_stanza_t* p = xmpp_stanza_get_child_by_name(decrypted_stanza, "payload");
                if (!p) {
                    log_warning("OX Stanza - no Payload");
                    return;
                }
                xmpp_stanza_t* b = xmpp_stanza_get_child_by_name(p, "body");
                if (!b) {
                    log_debug("OX Stanza - no body");
                    return;
                }
                message->plain = xmpp_stanza_get_text(b);
                message->encrypted = xmpp_stanza_get_text(ox);
            } else {
                cons_show("Unable to decrypt OX message (XEP-0373: OpenPGP for XMPP)");
                log_warning("OX Stanza text to stanza failed");
            }
        } else {
            // get alternative text from message body
            xmpp_stanza_t* b = xmpp_stanza_get_child_by_name(stanza, "body");
            if (b) {
                message->plain = xmpp_stanza_get_text(b);
            }
        }
    } else {
        log_warning("OX Stanza without openpgp stanza");
    }
#endif // HAVE_LIBGPGME
}

static gboolean
_handle_mam(xmpp_stanza_t* const stanza)
{
    xmpp_stanza_t* result = xmpp_stanza_get_child_by_name_and_ns(stanza, STANZA_NAME_RESULT, STANZA_NS_MAM2);
    if (!result) {
        return FALSE;
    }

    xmpp_stanza_t* forwarded = xmpp_stanza_get_child_by_ns(result, STANZA_NS_FORWARD);
    if (!forwarded) {
        log_warning("MAM received with no forwarded element");
        return FALSE;
    }

    // <result xmlns='urn:xmpp:mam:2' queryid='f27' id='5d398-28273-f7382'>
    // same as <stanza-id> from XEP-0359 for live messages
    const char* result_id = xmpp_stanza_get_id(result);

    GDateTime* timestamp = stanza_get_delay_from(forwarded, NULL);

    xmpp_stanza_t* message_stanza = xmpp_stanza_get_child_by_ns(forwarded, "jabber:client");

    _handle_chat(message_stanza, TRUE, FALSE, result_id, timestamp);

    return TRUE;
}

static void
_handle_pubsub(xmpp_stanza_t* const stanza, xmpp_stanza_t* const event)
{
    xmpp_stanza_t* child = xmpp_stanza_get_children(event);
    if (child) {
        const char* node = xmpp_stanza_get_attribute(child, STANZA_ATTR_NODE);
        if (node) {
            ProfMessageHandler* handler = g_hash_table_lookup(pubsub_event_handlers, node);
            if (handler) {
                int keep = handler->func(stanza, handler->userdata);
                if (!keep) {
                    g_hash_table_remove(pubsub_event_handlers, node);
                }
            }
        }
    }
}

static void
_send_message_stanza(xmpp_stanza_t* const stanza)
{
    char* text;
    size_t text_size;
    xmpp_stanza_to_text(stanza, &text, &text_size);

    xmpp_conn_t* conn = connection_get_conn();
    char* plugin_text = plugins_on_message_stanza_send(text);
    if (plugin_text) {
        xmpp_send_raw_string(conn, "%s", plugin_text);
        free(plugin_text);
    } else {
        xmpp_send_raw_string(conn, "%s", text);
    }
    xmpp_free(connection_get_ctx(), text);
}

/* ckeckOID = true: check origin-id
 * checkOID = false: check regular id
 */
bool
message_is_sent_by_us(const ProfMessage* const message, bool checkOID)
{
    bool ret = FALSE;

    // we check the </origin-id> for this we calculate a hash into it so we can detect
    // whether this client sent it. See connection_create_stanza_id()
    if (message) {
        char* tmp_id = NULL;

        if (checkOID && message->originid != NULL) {
            tmp_id = message->originid;
        } else if (!checkOID && message->id != NULL) {
            tmp_id = message->id;
        }

        if (tmp_id != NULL) {
            gsize tmp_len = strlen(tmp_id);

            // our client sents at CON_RAND_ID_LEN + identifier
            if (tmp_len > CON_RAND_ID_LEN) {
                char* uuid = g_strndup(tmp_id, CON_RAND_ID_LEN);
                const char* prof_identifier = connection_get_profanity_identifier();

                gchar* hmac = g_compute_hmac_for_string(G_CHECKSUM_SHA1,
                                                        (guchar*)prof_identifier, strlen(prof_identifier),
                                                        uuid, strlen(uuid));

                if (g_strcmp0(&tmp_id[CON_RAND_ID_LEN], hmac) == 0) {
                    ret = TRUE;
                }

                g_free(uuid);
                g_free(hmac);
            }
        }
    }

    return ret;
}

#ifdef HAVE_LIBGPGME
static xmpp_stanza_t*
_ox_openpgp_signcrypt(xmpp_ctx_t* ctx, const char* const to, const char* const text)
{
    time_t now = time(NULL);
    struct tm* tm = localtime(&now);
    char buf[255];
    strftime(buf, sizeof(buf), "%FT%T%z", tm);

    // build rpad
    int randnr = (rand() % 100) + 1;
    char rpad_data[randnr];
    for (int i = 0; i < randnr; i++) {
        int rchar = (rand() % 52) + 65;
        rpad_data[i] = rchar;
    }
    rpad_data[randnr - 1] = '\0';

    // signcrypt
    xmpp_stanza_t* signcrypt = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(signcrypt, "signcrypt");
    xmpp_stanza_set_ns(signcrypt, "urn:xmpp:openpgp:0");
    // to
    xmpp_stanza_t* s_to = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(s_to, "to");
    xmpp_stanza_set_attribute(s_to, "jid", to);
    // time
    xmpp_stanza_t* time = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(time, "time");
    xmpp_stanza_set_attribute(time, "stamp", buf);
    xmpp_stanza_set_name(time, "time");
    // rpad
    xmpp_stanza_t* rpad = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(rpad, "rpad");
    xmpp_stanza_t* rpad_text = xmpp_stanza_new(ctx);
    xmpp_stanza_set_text(rpad_text, rpad_data);
    // payload
    xmpp_stanza_t* payload = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(payload, "payload");
    // body
    xmpp_stanza_t* body = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(body, "body");
    xmpp_stanza_set_ns(body, "jabber:client");
    // text
    xmpp_stanza_t* body_text = xmpp_stanza_new(ctx);
    xmpp_stanza_set_text(body_text, text);
    xmpp_stanza_add_child(signcrypt, s_to);
    xmpp_stanza_add_child(signcrypt, time);
    xmpp_stanza_add_child(signcrypt, rpad);
    xmpp_stanza_add_child(rpad, rpad_text);
    xmpp_stanza_add_child(signcrypt, payload);
    xmpp_stanza_add_child(payload, body);
    xmpp_stanza_add_child(body, body_text);

    xmpp_stanza_release(body_text);
    xmpp_stanza_release(body);
    xmpp_stanza_release(rpad_text);
    xmpp_stanza_release(rpad);
    xmpp_stanza_release(time);
    xmpp_stanza_release(s_to);

    return signcrypt;
}
#endif // HAVE_LIBGPGME

void
message_request_voice(const char* const roomjid)
{
    xmpp_ctx_t* const ctx = connection_get_ctx();
    xmpp_stanza_t* stanza = stanza_request_voice(ctx, roomjid);

    log_debug("Requesting voice in %s", roomjid);

    _send_message_stanza(stanza);
    xmpp_stanza_release(stanza);
}

static gboolean
_handle_jingle_message(xmpp_stanza_t* const stanza)
{
    xmpp_stanza_t* propose = xmpp_stanza_get_child_by_name_and_ns(stanza, STANZA_NAME_PROPOSE, STANZA_NS_JINGLE_MESSAGE);

    if (propose) {
        xmpp_stanza_t* description = xmpp_stanza_get_child_by_ns(propose, STANZA_NS_JINGLE_RTP);
        if (description) {
            const char* const from = xmpp_stanza_get_from(stanza);
            cons_show("Ring ring: %s is trying to call you", from);
            cons_alert(NULL);
            return TRUE;
        }
    }
    return FALSE;
}

static gboolean
_should_ignore_based_on_silence(xmpp_stanza_t* const stanza)
{
    if (prefs_get_boolean(PREF_SILENCE_NON_ROSTER)) {
        const char* const from = xmpp_stanza_get_from(stanza);
        auto_jid Jid* from_jid = jid_create(from);
        PContact contact = roster_get_contact(from_jid->barejid);
        if (!contact) {
            log_debug("[Silence] Ignoring message from: %s", from);
            return TRUE;
        }
    }
    return FALSE;
}


context:
space:
mode: