dlls/opcservices/package.c

   1 /*
   2  * Copyright 2018 Nikolay Sivov for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "ntsecapi.h"
  25 #include "xmllite.h"
  26
  27 #include "wine/debug.h"
  28 #include "wine/list.h"
  29 #include "wine/unicode.h"
  30
  31 #include "opc_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(msopc);
  34
  35 struct opc_content
  36 {
  37     LONG refcount;
  38     BYTE *data;
  39     ULARGE_INTEGER size;
  40 };
  41
  42 struct opc_content_stream
  43 {
  44     IStream IStream_iface;
  45     LONG refcount;
  46
  47     struct opc_content *content;
  48     ULARGE_INTEGER pos;
  49 };
  50
  51 struct opc_package
  52 {
  53     IOpcPackage IOpcPackage_iface;
  54     LONG refcount;
  55
  56     IOpcPartSet *part_set;
  57     IOpcRelationshipSet *relationship_set;
  58     IOpcUri *source_uri;
  59 };
  60
  61 struct opc_part_enum
  62 {
  63     IOpcPartEnumerator IOpcPartEnumerator_iface;
  64     LONG refcount;
  65
  66     struct opc_part_set *part_set;
  67     size_t pos;
  68     GUID id;
  69 };
  70
  71 struct opc_part
  72 {
  73     IOpcPart IOpcPart_iface;
  74     LONG refcount;
  75
  76     IOpcPartUri *name;
  77     WCHAR *content_type;
  78     DWORD compression_options;
  79     IOpcRelationshipSet *relationship_set;
  80     struct opc_content *content;
  81 };
  82
  83 struct opc_part_set
  84 {
  85     IOpcPartSet IOpcPartSet_iface;
  86     LONG refcount;
  87
  88     struct opc_part **parts;
  89     size_t size;
  90     size_t count;
  91     GUID id;
  92 };
  93
  94 struct opc_rel_enum
  95 {
  96     IOpcRelationshipEnumerator IOpcRelationshipEnumerator_iface;
  97     LONG refcount;
  98
  99     struct opc_relationship_set *rel_set;
 100     size_t pos;
 101     GUID id;
 102 };
 103
 104 struct opc_relationship
 105 {
 106     IOpcRelationship IOpcRelationship_iface;
 107     LONG refcount;
 108
 109     WCHAR *id;
 110     WCHAR *type;
 111     IUri *target;
 112     OPC_URI_TARGET_MODE target_mode;
 113     IOpcUri *source_uri;
 114 };
 115
 116 struct opc_relationship_set
 117 {
 118     IOpcRelationshipSet IOpcRelationshipSet_iface;
 119     LONG refcount;
 120
 121     struct opc_relationship **relationships;
 122     size_t size;
 123     size_t count;
 124     IOpcUri *source_uri;
 125     GUID id;
 126 };
 127
 128 static inline struct opc_package *impl_from_IOpcPackage(IOpcPackage *iface)
 129 {
 130     return CONTAINING_RECORD(iface, struct opc_package, IOpcPackage_iface);
 131 }
 132
 133 static inline struct opc_part_set *impl_from_IOpcPartSet(IOpcPartSet *iface)
 134 {
 135     return CONTAINING_RECORD(iface, struct opc_part_set, IOpcPartSet_iface);
 136 }
 137
 138 static inline struct opc_part *impl_from_IOpcPart(IOpcPart *iface)
 139 {
 140     return CONTAINING_RECORD(iface, struct opc_part, IOpcPart_iface);
 141 }
 142
 143 static inline struct opc_relationship_set *impl_from_IOpcRelationshipSet(IOpcRelationshipSet *iface)
 144 {
 145     return CONTAINING_RECORD(iface, struct opc_relationship_set, IOpcRelationshipSet_iface);
 146 }
 147
 148 static inline struct opc_relationship *impl_from_IOpcRelationship(IOpcRelationship *iface)
 149 {
 150     return CONTAINING_RECORD(iface, struct opc_relationship, IOpcRelationship_iface);
 151 }
 152
 153 static inline struct opc_content_stream *impl_from_IStream(IStream *iface)
 154 {
 155     return CONTAINING_RECORD(iface, struct opc_content_stream, IStream_iface);
 156 }
 157
 158 static inline struct opc_part_enum *impl_from_IOpcPartEnumerator(IOpcPartEnumerator *iface)
 159 {
 160     return CONTAINING_RECORD(iface, struct opc_part_enum, IOpcPartEnumerator_iface);
 161 }
 162
 163 static inline struct opc_rel_enum *impl_from_IOpcRelationshipEnumerator(IOpcRelationshipEnumerator *iface)
 164 {
 165     return CONTAINING_RECORD(iface, struct opc_rel_enum, IOpcRelationshipEnumerator_iface);
 166 }
 167
 168 static void opc_content_release(struct opc_content *content)
 169 {
 170     ULONG refcount = InterlockedDecrement(&content->refcount);
 171
 172     if (!refcount)
 173     {
 174         heap_free(content->data);
 175         heap_free(content);
 176     }
 177 }
 178
 179 static HRESULT opc_part_enum_create(struct opc_part_set *part_set, IOpcPartEnumerator **out);
 180
 181 static HRESULT WINAPI opc_part_enum_QueryInterface(IOpcPartEnumerator *iface, REFIID iid, void **out)
 182 {
 183     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 184
 185     if (IsEqualIID(&IID_IOpcPartEnumerator, iid) ||
 186             IsEqualIID(&IID_IUnknown, iid))
 187     {
 188         *out = iface;
 189         IOpcPartEnumerator_AddRef(iface);
 190         return S_OK;
 191     }
 192
 193     *out = NULL;
 194     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 195     return E_NOINTERFACE;
 196 }
 197
 198 static ULONG WINAPI opc_part_enum_AddRef(IOpcPartEnumerator *iface)
 199 {
 200     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 201     ULONG refcount = InterlockedIncrement(&part_enum->refcount);
 202
 203     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 204
 205     return refcount;
 206 }
 207
 208 static ULONG WINAPI opc_part_enum_Release(IOpcPartEnumerator *iface)
 209 {
 210     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 211     ULONG refcount = InterlockedDecrement(&part_enum->refcount);
 212
 213     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 214
 215     if (!refcount)
 216     {
 217         IOpcPartSet_Release(&part_enum->part_set->IOpcPartSet_iface);
 218         heap_free(part_enum);
 219     }
 220
 221     return refcount;
 222 }
 223
 224 static BOOL has_part_collection_changed(const struct opc_part_enum *part_enum)
 225 {
 226     return !IsEqualGUID(&part_enum->id, &part_enum->part_set->id);
 227 }
 228
 229 static HRESULT WINAPI opc_part_enum_MoveNext(IOpcPartEnumerator *iface, BOOL *has_next)
 230 {
 231     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 232
 233     TRACE("iface %p, has_next %p.\n", iface, has_next);
 234
 235     if (!has_next)
 236         return E_POINTER;
 237
 238     if (has_part_collection_changed(part_enum))
 239         return OPC_E_ENUM_COLLECTION_CHANGED;
 240
 241     if (part_enum->part_set->count && (part_enum->pos == ~(size_t)0 || part_enum->pos < part_enum->part_set->count))
 242         part_enum->pos++;
 243
 244     *has_next = part_enum->pos < part_enum->part_set->count;
 245
 246     return S_OK;
 247 }
 248
 249 static HRESULT WINAPI opc_part_enum_MovePrevious(IOpcPartEnumerator *iface, BOOL *has_previous)
 250 {
 251     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 252
 253     TRACE("iface %p, has_previous %p.\n", iface, has_previous);
 254
 255     if (!has_previous)
 256         return E_POINTER;
 257
 258     if (has_part_collection_changed(part_enum))
 259         return OPC_E_ENUM_COLLECTION_CHANGED;
 260
 261     if (part_enum->pos != ~(size_t)0)
 262         part_enum->pos--;
 263
 264     *has_previous = part_enum->pos != ~(size_t)0;
 265
 266     return S_OK;
 267 }
 268
 269 static HRESULT WINAPI opc_part_enum_GetCurrent(IOpcPartEnumerator *iface, IOpcPart **part)
 270 {
 271     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 272
 273     TRACE("iface %p, part %p.\n", iface, part);
 274
 275     if (!part)
 276         return E_POINTER;
 277
 278     *part = NULL;
 279
 280     if (has_part_collection_changed(part_enum))
 281         return OPC_E_ENUM_COLLECTION_CHANGED;
 282
 283     if (part_enum->pos < part_enum->part_set->count)
 284     {
 285         *part = &part_enum->part_set->parts[part_enum->pos]->IOpcPart_iface;
 286         IOpcPart_AddRef(*part);
 287     }
 288
 289     return *part ? S_OK : OPC_E_ENUM_INVALID_POSITION;
 290 }
 291
 292 static HRESULT WINAPI opc_part_enum_Clone(IOpcPartEnumerator *iface, IOpcPartEnumerator **out)
 293 {
 294     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 295
 296     TRACE("iface %p, out %p.\n", iface, out);
 297
 298     if (!out)
 299         return E_POINTER;
 300
 301     if (has_part_collection_changed(part_enum))
 302     {
 303         *out = NULL;
 304         return OPC_E_ENUM_COLLECTION_CHANGED;
 305     }
 306
 307     return opc_part_enum_create(part_enum->part_set, out);
 308 }
 309
 310 static const IOpcPartEnumeratorVtbl opc_part_enum_vtbl =
 311 {
 312     opc_part_enum_QueryInterface,
 313     opc_part_enum_AddRef,
 314     opc_part_enum_Release,
 315     opc_part_enum_MoveNext,
 316     opc_part_enum_MovePrevious,
 317     opc_part_enum_GetCurrent,
 318     opc_part_enum_Clone,
 319 };
 320
 321 static HRESULT opc_part_enum_create(struct opc_part_set *part_set, IOpcPartEnumerator **out)
 322 {
 323     struct opc_part_enum *part_enum;
 324
 325     if (!(part_enum = heap_alloc_zero(sizeof(*part_enum))))
 326         return E_OUTOFMEMORY;
 327
 328     part_enum->IOpcPartEnumerator_iface.lpVtbl = &opc_part_enum_vtbl;
 329     part_enum->refcount = 1;
 330     part_enum->part_set = part_set;
 331     IOpcPartSet_AddRef(&part_set->IOpcPartSet_iface);
 332     part_enum->pos = ~(size_t)0;
 333     part_enum->id = part_set->id;
 334
 335     *out = &part_enum->IOpcPartEnumerator_iface;
 336     TRACE("Created part enumerator %p.\n", *out);
 337     return S_OK;
 338 }
 339
 340 static HRESULT opc_rel_enum_create(struct opc_relationship_set *rel_set, IOpcRelationshipEnumerator **out);
 341
 342 static HRESULT WINAPI opc_rel_enum_QueryInterface(IOpcRelationshipEnumerator *iface, REFIID iid, void **out)
 343 {
 344     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 345
 346     if (IsEqualIID(&IID_IOpcRelationshipEnumerator, iid) ||
 347             IsEqualIID(&IID_IUnknown, iid))
 348     {
 349         *out = iface;
 350         IOpcRelationshipEnumerator_AddRef(iface);
 351         return S_OK;
 352     }
 353
 354     *out = NULL;
 355     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 356     return E_NOINTERFACE;
 357 }
 358
 359 static ULONG WINAPI opc_rel_enum_AddRef(IOpcRelationshipEnumerator *iface)
 360 {
 361     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 362     ULONG refcount = InterlockedIncrement(&rel_enum->refcount);
 363
 364     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 365
 366     return refcount;
 367 }
 368
 369 static ULONG WINAPI opc_rel_enum_Release(IOpcRelationshipEnumerator *iface)
 370 {
 371     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 372     ULONG refcount = InterlockedDecrement(&rel_enum->refcount);
 373
 374     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 375
 376     if (!refcount)
 377     {
 378         IOpcRelationshipSet_Release(&rel_enum->rel_set->IOpcRelationshipSet_iface);
 379         heap_free(rel_enum);
 380     }
 381
 382     return refcount;
 383 }
 384
 385 static BOOL has_rel_collection_changed(const struct opc_rel_enum *rel_enum)
 386 {
 387     return !IsEqualGUID(&rel_enum->id, &rel_enum->rel_set->id);
 388 }
 389
 390 static HRESULT WINAPI opc_rel_enum_MoveNext(IOpcRelationshipEnumerator *iface, BOOL *has_next)
 391 {
 392     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 393
 394     TRACE("iface %p, has_next %p.\n", iface, has_next);
 395
 396     if (!has_next)
 397         return E_POINTER;
 398
 399     if (has_rel_collection_changed(rel_enum))
 400         return OPC_E_ENUM_COLLECTION_CHANGED;
 401
 402     if (rel_enum->rel_set->count && (rel_enum->pos == ~(size_t)0 || rel_enum->pos < rel_enum->rel_set->count))
 403         rel_enum->pos++;
 404
 405     *has_next = rel_enum->pos < rel_enum->rel_set->count;
 406
 407     return S_OK;
 408 }
 409
 410 static HRESULT WINAPI opc_rel_enum_MovePrevious(IOpcRelationshipEnumerator *iface, BOOL *has_previous)
 411 {
 412     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 413
 414     TRACE("iface %p, has_previous %p.\n", iface, has_previous);
 415
 416     if (!has_previous)
 417         return E_POINTER;
 418
 419     if (has_rel_collection_changed(rel_enum))
 420         return OPC_E_ENUM_COLLECTION_CHANGED;
 421
 422     if (rel_enum->pos != ~(size_t)0)
 423         rel_enum->pos--;
 424
 425     *has_previous = rel_enum->pos != ~(size_t)0;
 426
 427     return S_OK;
 428 }
 429
 430 static HRESULT WINAPI opc_rel_enum_GetCurrent(IOpcRelationshipEnumerator *iface, IOpcRelationship **rel)
 431 {
 432     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 433
 434     TRACE("iface %p, rel %p.\n", iface, rel);
 435
 436     if (!rel)
 437         return E_POINTER;
 438
 439     *rel = NULL;
 440
 441     if (has_rel_collection_changed(rel_enum))
 442         return OPC_E_ENUM_COLLECTION_CHANGED;
 443
 444     if (rel_enum->pos < rel_enum->rel_set->count)
 445     {
 446         *rel = &rel_enum->rel_set->relationships[rel_enum->pos]->IOpcRelationship_iface;
 447         IOpcRelationship_AddRef(*rel);
 448     }
 449
 450     return *rel ? S_OK : OPC_E_ENUM_INVALID_POSITION;
 451 }
 452
 453 static HRESULT WINAPI opc_rel_enum_Clone(IOpcRelationshipEnumerator *iface, IOpcRelationshipEnumerator **out)
 454 {
 455     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 456
 457     TRACE("iface %p, out %p.\n", iface, out);
 458
 459     if (!out)
 460         return E_POINTER;
 461
 462     if (has_rel_collection_changed(rel_enum))
 463     {
 464         *out = NULL;
 465         return OPC_E_ENUM_COLLECTION_CHANGED;
 466     }
 467
 468     return opc_rel_enum_create(rel_enum->rel_set, out);
 469 }
 470
 471 static const IOpcRelationshipEnumeratorVtbl opc_rel_enum_vtbl =
 472 {
 473     opc_rel_enum_QueryInterface,
 474     opc_rel_enum_AddRef,
 475     opc_rel_enum_Release,
 476     opc_rel_enum_MoveNext,
 477     opc_rel_enum_MovePrevious,
 478     opc_rel_enum_GetCurrent,
 479     opc_rel_enum_Clone,
 480 };
 481
 482 static HRESULT opc_rel_enum_create(struct opc_relationship_set *rel_set, IOpcRelationshipEnumerator **out)
 483 {
 484     struct opc_rel_enum *rel_enum;
 485
 486     if (!(rel_enum = heap_alloc_zero(sizeof(*rel_enum))))
 487         return E_OUTOFMEMORY;
 488
 489     rel_enum->IOpcRelationshipEnumerator_iface.lpVtbl = &opc_rel_enum_vtbl;
 490     rel_enum->refcount = 1;
 491     rel_enum->rel_set = rel_set;
 492     IOpcRelationshipSet_AddRef(&rel_set->IOpcRelationshipSet_iface);
 493     rel_enum->pos = ~(size_t)0;
 494     rel_enum->id = rel_set->id;
 495
 496     *out = &rel_enum->IOpcRelationshipEnumerator_iface;
 497     TRACE("Created relationship enumerator %p.\n", *out);
 498     return S_OK;
 499 }
 500
 501 static HRESULT WINAPI opc_content_stream_QueryInterface(IStream *iface, REFIID iid, void **out)
 502 {
 503     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 504
 505     if (IsEqualIID(iid, &IID_IStream) ||
 506             IsEqualIID(iid, &IID_ISequentialStream) ||
 507             IsEqualIID(iid, &IID_IUnknown))
 508     {
 509         *out = iface;
 510         IStream_AddRef(iface);
 511         return S_OK;
 512     }
 513
 514     *out = NULL;
 515     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 516     return E_NOINTERFACE;
 517 }
 518
 519 static ULONG WINAPI opc_content_stream_AddRef(IStream *iface)
 520 {
 521     struct opc_content_stream *stream = impl_from_IStream(iface);
 522     ULONG refcount = InterlockedIncrement(&stream->refcount);
 523
 524     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 525
 526     return refcount;
 527 }
 528
 529 static ULONG WINAPI opc_content_stream_Release(IStream *iface)
 530 {
 531     struct opc_content_stream *stream = impl_from_IStream(iface);
 532     ULONG refcount = InterlockedDecrement(&stream->refcount);
 533
 534     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 535
 536     if (!refcount)
 537     {
 538         opc_content_release(stream->content);
 539         heap_free(stream);
 540     }
 541
 542     return refcount;
 543 }
 544
 545 static HRESULT WINAPI opc_content_stream_Read(IStream *iface, void *buff, ULONG size, ULONG *num_read)
 546 {
 547     struct opc_content_stream *stream = impl_from_IStream(iface);
 548     DWORD read = 0;
 549
 550     TRACE("iface %p, buff %p, size %u, num_read %p.\n", iface, buff, size, num_read);
 551
 552     if (!num_read)
 553         num_read = &read;
 554
 555     if (stream->content->size.QuadPart - stream->pos.QuadPart < size)
 556         *num_read = stream->content->size.QuadPart - stream->pos.QuadPart;
 557     else
 558         *num_read = size;
 559
 560     if (*num_read)
 561         memcpy(buff, stream->content->data + stream->pos.QuadPart, *num_read);
 562
 563     stream->pos.QuadPart += *num_read;
 564
 565     return S_OK;
 566 }
 567
 568 static HRESULT WINAPI opc_content_stream_Write(IStream *iface, const void *data, ULONG size, ULONG *num_written)
 569 {
 570     struct opc_content_stream *stream = impl_from_IStream(iface);
 571     DWORD written = 0;
 572
 573     TRACE("iface %p, data %p, size %u, num_written %p.\n", iface, data, size, num_written);
 574
 575     if (!num_written)
 576         num_written = &written;
 577
 578     *num_written = 0;
 579
 580     if (size > stream->content->size.QuadPart - stream->pos.QuadPart)
 581     {
 582         void *ptr = heap_realloc(stream->content->data, stream->pos.QuadPart + size);
 583         if (!ptr)
 584             return E_OUTOFMEMORY;
 585         stream->content->data = ptr;
 586     }
 587
 588     memcpy(stream->content->data + stream->pos.QuadPart, data, size);
 589     stream->pos.QuadPart += size;
 590     stream->content->size.QuadPart += size;
 591     *num_written = size;
 592
 593     return S_OK;
 594 }
 595
 596 static HRESULT WINAPI opc_content_stream_Seek(IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *newpos)
 597 {
 598     struct opc_content_stream *stream = impl_from_IStream(iface);
 599     ULARGE_INTEGER pos;
 600
 601     TRACE("iface %p, move %s, origin %d, newpos %p.\n", iface, wine_dbgstr_longlong(move.QuadPart), origin, newpos);
 602
 603     switch (origin)
 604     {
 605     case STREAM_SEEK_SET:
 606         pos.QuadPart = move.QuadPart;
 607         break;
 608     case STREAM_SEEK_CUR:
 609         pos.QuadPart = stream->pos.QuadPart + move.QuadPart;
 610         break;
 611     case STREAM_SEEK_END:
 612         pos.QuadPart = stream->content->size.QuadPart + move.QuadPart;
 613         break;
 614     default:
 615         WARN("Unknown origin mode %d.\n", origin);
 616         return E_INVALIDARG;
 617     }
 618
 619     stream->pos = pos;
 620
 621     if (newpos)
 622         *newpos = stream->pos;
 623
 624     return S_OK;
 625 }
 626
 627 static HRESULT WINAPI opc_content_stream_SetSize(IStream *iface, ULARGE_INTEGER size)
 628 {
 629     FIXME("iface %p, size %s stub!\n", iface, wine_dbgstr_longlong(size.QuadPart));
 630
 631     return E_NOTIMPL;
 632 }
 633
 634 static HRESULT WINAPI opc_content_stream_CopyTo(IStream *iface, IStream *dest, ULARGE_INTEGER size,
 635         ULARGE_INTEGER *num_read, ULARGE_INTEGER *written)
 636 {
 637     FIXME("iface %p, dest %p, size %s, num_read %p, written %p stub!\n", iface, dest,
 638             wine_dbgstr_longlong(size.QuadPart), num_read, written);
 639
 640     return E_NOTIMPL;
 641 }
 642
 643 static HRESULT WINAPI opc_content_stream_Commit(IStream *iface, DWORD flags)
 644 {
 645     FIXME("iface %p, flags %#x stub!\n", iface, flags);
 646
 647     return E_NOTIMPL;
 648 }
 649
 650 static HRESULT WINAPI opc_content_stream_Revert(IStream *iface)
 651 {
 652     FIXME("iface %p stub!\n", iface);
 653
 654     return E_NOTIMPL;
 655 }
 656
 657 static HRESULT WINAPI opc_content_stream_LockRegion(IStream *iface, ULARGE_INTEGER offset,
 658         ULARGE_INTEGER size, DWORD lock_type)
 659 {
 660     FIXME("iface %p, offset %s, size %s, lock_type %d stub!\n", iface, wine_dbgstr_longlong(offset.QuadPart),
 661             wine_dbgstr_longlong(size.QuadPart), lock_type);
 662
 663     return E_NOTIMPL;
 664 }
 665
 666 static HRESULT WINAPI opc_content_stream_UnlockRegion(IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER size,
 667         DWORD lock_type)
 668 {
 669     FIXME("iface %p, offset %s, size %s, lock_type %d stub!\n", iface, wine_dbgstr_longlong(offset.QuadPart),
 670             wine_dbgstr_longlong(size.QuadPart), lock_type);
 671
 672     return E_NOTIMPL;
 673 }
 674
 675 static HRESULT WINAPI opc_content_stream_Stat(IStream *iface, STATSTG *statstg, DWORD flag)
 676 {
 677     FIXME("iface %p, statstg %p, flag %d stub!\n", iface, statstg, flag);
 678
 679     return E_NOTIMPL;
 680 }
 681
 682 static HRESULT WINAPI opc_content_stream_Clone(IStream *iface, IStream **result)
 683 {
 684     FIXME("iface %p, result %p stub!\n", iface, result);
 685
 686     return E_NOTIMPL;
 687 }
 688
 689 static const IStreamVtbl opc_content_stream_vtbl =
 690 {
 691     opc_content_stream_QueryInterface,
 692     opc_content_stream_AddRef,
 693     opc_content_stream_Release,
 694     opc_content_stream_Read,
 695     opc_content_stream_Write,
 696     opc_content_stream_Seek,
 697     opc_content_stream_SetSize,
 698     opc_content_stream_CopyTo,
 699     opc_content_stream_Commit,
 700     opc_content_stream_Revert,
 701     opc_content_stream_LockRegion,
 702     opc_content_stream_UnlockRegion,
 703     opc_content_stream_Stat,
 704     opc_content_stream_Clone,
 705 };
 706
 707 static HRESULT opc_content_stream_create(struct opc_content *content, IStream **out)
 708 {
 709     struct opc_content_stream *stream;
 710
 711     if (!(stream = heap_alloc_zero(sizeof(*stream))))
 712         return E_OUTOFMEMORY;
 713
 714     stream->IStream_iface.lpVtbl = &opc_content_stream_vtbl;
 715     stream->refcount = 1;
 716     stream->content = content;
 717     InterlockedIncrement(&content->refcount);
 718
 719     *out = &stream->IStream_iface;
 720
 721     TRACE("Created content stream %p.\n", *out);
 722     return S_OK;
 723 }
 724
 725 static HRESULT opc_relationship_set_create(IOpcUri *source_uri, IOpcRelationshipSet **relationship_set);
 726
 727 static WCHAR *opc_strdupW(const WCHAR *str)
 728 {
 729     WCHAR *ret = NULL;
 730
 731     if (str)
 732     {
 733         size_t size;
 734
 735         size = (strlenW(str) + 1) * sizeof(WCHAR);
 736         ret = CoTaskMemAlloc(size);
 737         if (ret)
 738             memcpy(ret, str, size);
 739     }
 740
 741     return ret;
 742 }
 743
 744 static HRESULT WINAPI opc_part_QueryInterface(IOpcPart *iface, REFIID iid, void **out)
 745 {
 746     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 747
 748     if (IsEqualIID(iid, &IID_IOpcPart) ||
 749             IsEqualIID(iid, &IID_IUnknown))
 750     {
 751         *out = iface;
 752         IOpcPart_AddRef(iface);
 753         return S_OK;
 754     }
 755
 756     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 757     return E_NOINTERFACE;
 758 }
 759
 760 static ULONG WINAPI opc_part_AddRef(IOpcPart *iface)
 761 {
 762     struct opc_part *part = impl_from_IOpcPart(iface);
 763     ULONG refcount = InterlockedIncrement(&part->refcount);
 764
 765     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 766
 767     return refcount;
 768 }
 769
 770 static ULONG WINAPI opc_part_Release(IOpcPart *iface)
 771 {
 772     struct opc_part *part = impl_from_IOpcPart(iface);
 773     ULONG refcount = InterlockedDecrement(&part->refcount);
 774
 775     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 776
 777     if (!refcount)
 778     {
 779         if (part->relationship_set)
 780             IOpcRelationshipSet_Release(part->relationship_set);
 781         IOpcPartUri_Release(part->name);
 782         CoTaskMemFree(part->content_type);
 783         opc_content_release(part->content);
 784         heap_free(part);
 785     }
 786
 787     return refcount;
 788 }
 789
 790 static HRESULT WINAPI opc_part_GetRelationshipSet(IOpcPart *iface, IOpcRelationshipSet **relationship_set)
 791 {
 792     struct opc_part *part = impl_from_IOpcPart(iface);
 793     HRESULT hr;
 794
 795     TRACE("iface %p, relationship_set %p.\n", iface, relationship_set);
 796
 797     if (!part->relationship_set && FAILED(hr = opc_relationship_set_create((IOpcUri *)part->name, &part->relationship_set)))
 798         return hr;
 799
 800     *relationship_set = part->relationship_set;
 801     IOpcRelationshipSet_AddRef(*relationship_set);
 802
 803     return S_OK;
 804 }
 805
 806 static HRESULT WINAPI opc_part_GetContentStream(IOpcPart *iface, IStream **stream)
 807 {
 808     struct opc_part *part = impl_from_IOpcPart(iface);
 809
 810     TRACE("iface %p, stream %p.\n", iface, stream);
 811
 812     if (!stream)
 813         return E_POINTER;
 814
 815     return opc_content_stream_create(part->content, stream);
 816 }
 817
 818 static HRESULT WINAPI opc_part_GetName(IOpcPart *iface, IOpcPartUri **name)
 819 {
 820     struct opc_part *part = impl_from_IOpcPart(iface);
 821
 822     TRACE("iface %p, name %p.\n", iface, name);
 823
 824     *name = part->name;
 825     IOpcPartUri_AddRef(*name);
 826
 827     return S_OK;
 828 }
 829
 830 static HRESULT WINAPI opc_part_GetContentType(IOpcPart *iface, LPWSTR *type)
 831 {
 832     struct opc_part *part = impl_from_IOpcPart(iface);
 833
 834     TRACE("iface %p, type %p.\n", iface, type);
 835
 836     *type = opc_strdupW(part->content_type);
 837     return *type ? S_OK : E_OUTOFMEMORY;
 838 }
 839
 840 static HRESULT WINAPI opc_part_GetCompressionOptions(IOpcPart *iface, OPC_COMPRESSION_OPTIONS *options)
 841 {
 842     struct opc_part *part = impl_from_IOpcPart(iface);
 843
 844     TRACE("iface %p, options %p.\n", iface, options);
 845
 846     *options = part->compression_options;
 847     return S_OK;
 848 }
 849
 850 static const IOpcPartVtbl opc_part_vtbl =
 851 {
 852     opc_part_QueryInterface,
 853     opc_part_AddRef,
 854     opc_part_Release,
 855     opc_part_GetRelationshipSet,
 856     opc_part_GetContentStream,
 857     opc_part_GetName,
 858     opc_part_GetContentType,
 859     opc_part_GetCompressionOptions,
 860 };
 861
 862 static HRESULT opc_part_create(struct opc_part_set *set, IOpcPartUri *name, const WCHAR *content_type,
 863         DWORD compression_options, IOpcPart **out)
 864 {
 865     struct opc_part *part;
 866
 867     if (!opc_array_reserve((void **)&set->parts, &set->size, set->count + 1, sizeof(*set->parts)))
 868         return E_OUTOFMEMORY;
 869
 870     if (!(part = heap_alloc_zero(sizeof(*part))))
 871         return E_OUTOFMEMORY;
 872
 873     part->IOpcPart_iface.lpVtbl = &opc_part_vtbl;
 874     part->refcount = 1;
 875     part->name = name;
 876     IOpcPartUri_AddRef(name);
 877     part->compression_options = compression_options;
 878     if (!(part->content_type = opc_strdupW(content_type)))
 879     {
 880         IOpcPart_Release(&part->IOpcPart_iface);
 881         return E_OUTOFMEMORY;
 882     }
 883
 884     part->content = heap_alloc_zero(sizeof(*part->content));
 885     if (!part->content)
 886     {
 887         IOpcPart_Release(&part->IOpcPart_iface);
 888         return E_OUTOFMEMORY;
 889     }
 890     part->content->refcount = 1;
 891
 892     set->parts[set->count++] = part;
 893     IOpcPart_AddRef(&part->IOpcPart_iface);
 894     CoCreateGuid(&set->id);
 895
 896     *out = &part->IOpcPart_iface;
 897     TRACE("Created part %p.\n", *out);
 898     return S_OK;
 899 }
 900
 901 static struct opc_part *opc_part_set_get_part(const struct opc_part_set *part_set, IOpcPartUri *name)
 902 {
 903     BOOL is_equal;
 904     size_t i;
 905
 906     for (i = 0; i < part_set->count; ++i)
 907     {
 908         is_equal = FALSE;
 909         if (IOpcPartUri_IsEqual(part_set->parts[i]->name, (IUri *)name, &is_equal) == S_OK && is_equal)
 910             return part_set->parts[i];
 911     }
 912
 913     return NULL;
 914 }
 915
 916 static HRESULT WINAPI opc_part_set_QueryInterface(IOpcPartSet *iface, REFIID iid, void **out)
 917 {
 918     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 919
 920     if (IsEqualIID(iid, &IID_IOpcPartSet) ||
 921             IsEqualIID(iid, &IID_IUnknown))
 922     {
 923         *out = iface;
 924         IOpcPartSet_AddRef(iface);
 925         return S_OK;
 926     }
 927
 928     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 929     return E_NOINTERFACE;
 930 }
 931
 932 static ULONG WINAPI opc_part_set_AddRef(IOpcPartSet *iface)
 933 {
 934     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
 935     ULONG refcount = InterlockedIncrement(&part_set->refcount);
 936
 937     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 938
 939     return refcount;
 940 }
 941
 942 static ULONG WINAPI opc_part_set_Release(IOpcPartSet *iface)
 943 {
 944     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
 945     ULONG refcount = InterlockedDecrement(&part_set->refcount);
 946
 947     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 948
 949     if (!refcount)
 950     {
 951         size_t i;
 952
 953         for (i = 0; i < part_set->count; ++i)
 954             IOpcPart_Release(&part_set->parts[i]->IOpcPart_iface);
 955         heap_free(part_set->parts);
 956         heap_free(part_set);
 957     }
 958
 959     return refcount;
 960 }
 961
 962 static HRESULT WINAPI opc_part_set_GetPart(IOpcPartSet *iface, IOpcPartUri *name, IOpcPart **out)
 963 {
 964     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
 965     struct opc_part *part;
 966
 967     TRACE("iface %p, name %p, out %p.\n", iface, name, out);
 968
 969     if (!out)
 970         return E_POINTER;
 971
 972     *out = NULL;
 973
 974     if (!name)
 975         return E_POINTER;
 976
 977     if ((part = opc_part_set_get_part(part_set, name)))
 978     {
 979         *out = &part->IOpcPart_iface;
 980         IOpcPart_AddRef(*out);
 981     }
 982
 983     return *out ? S_OK : OPC_E_NO_SUCH_PART;
 984 }
 985
 986 static HRESULT WINAPI opc_part_set_CreatePart(IOpcPartSet *iface, IOpcPartUri *name, LPCWSTR content_type,
 987         OPC_COMPRESSION_OPTIONS compression_options, IOpcPart **part)
 988 {
 989     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
 990
 991     TRACE("iface %p, name %p, content_type %s, compression_options %#x, part %p.\n", iface, name,
 992             debugstr_w(content_type), compression_options, part);
 993
 994     if (!part)
 995         return E_POINTER;
 996
 997     *part = NULL;
 998
 999     if (!name)
1000         return E_POINTER;
1001
1002     if (opc_part_set_get_part(part_set, name))
1003         return OPC_E_DUPLICATE_PART;
1004
1005     return opc_part_create(part_set, name, content_type, compression_options, part);
1006 }
1007
1008 static HRESULT WINAPI opc_part_set_DeletePart(IOpcPartSet *iface, IOpcPartUri *name)
1009 {
1010     FIXME("iface %p, name %p stub!\n", iface, name);
1011
1012     return E_NOTIMPL;
1013 }
1014
1015 static HRESULT WINAPI opc_part_set_PartExists(IOpcPartSet *iface, IOpcPartUri *name, BOOL *exists)
1016 {
1017     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
1018
1019     TRACE("iface %p, name %p, exists %p.\n", iface, name, exists);
1020
1021     if (!name || !exists)
1022         return E_POINTER;
1023
1024     *exists = opc_part_set_get_part(part_set, name) != NULL;
1025
1026     return S_OK;
1027 }
1028
1029 static HRESULT WINAPI opc_part_set_GetEnumerator(IOpcPartSet *iface, IOpcPartEnumerator **enumerator)
1030 {
1031     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
1032
1033     TRACE("iface %p, enumerator %p.\n", iface, enumerator);
1034
1035     if (!enumerator)
1036         return E_POINTER;
1037
1038     return opc_part_enum_create(part_set, enumerator);
1039 }
1040
1041 static const IOpcPartSetVtbl opc_part_set_vtbl =
1042 {
1043     opc_part_set_QueryInterface,
1044     opc_part_set_AddRef,
1045     opc_part_set_Release,
1046     opc_part_set_GetPart,
1047     opc_part_set_CreatePart,
1048     opc_part_set_DeletePart,
1049     opc_part_set_PartExists,
1050     opc_part_set_GetEnumerator,
1051 };
1052
1053 static HRESULT WINAPI opc_relationship_QueryInterface(IOpcRelationship *iface, REFIID iid, void **out)
1054 {
1055     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
1056
1057     if (IsEqualIID(iid, &IID_IOpcRelationship) ||
1058             IsEqualIID(iid, &IID_IUnknown))
1059     {
1060         *out = iface;
1061         IOpcRelationship_AddRef(iface);
1062         return S_OK;
1063     }
1064
1065     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
1066     return E_NOINTERFACE;
1067 }
1068
1069 static ULONG WINAPI opc_relationship_AddRef(IOpcRelationship *iface)
1070 {
1071     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1072     ULONG refcount = InterlockedIncrement(&relationship->refcount);
1073
1074     TRACE("%p increasing refcount to %u.\n", iface, refcount);
1075
1076     return refcount;
1077 }
1078
1079 static ULONG WINAPI opc_relationship_Release(IOpcRelationship *iface)
1080 {
1081     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1082     ULONG refcount = InterlockedDecrement(&relationship->refcount);
1083
1084     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
1085
1086     if (!refcount)
1087     {
1088         CoTaskMemFree(relationship->id);
1089         CoTaskMemFree(relationship->type);
1090         IOpcUri_Release(relationship->source_uri);
1091         IUri_Release(relationship->target);
1092         heap_free(relationship);
1093     }
1094
1095     return refcount;
1096 }
1097
1098 static HRESULT WINAPI opc_relationship_GetId(IOpcRelationship *iface, WCHAR **id)
1099 {
1100     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1101
1102     TRACE("iface %p, id %p.\n", iface, id);
1103
1104     *id = opc_strdupW(relationship->id);
1105     return *id ? S_OK : E_OUTOFMEMORY;
1106 }
1107
1108 static HRESULT WINAPI opc_relationship_GetRelationshipType(IOpcRelationship *iface, WCHAR **type)
1109 {
1110     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1111
1112     TRACE("iface %p, type %p.\n", iface, type);
1113
1114     *type = opc_strdupW(relationship->type);
1115     return *type ? S_OK : E_OUTOFMEMORY;
1116 }
1117
1118 static HRESULT WINAPI opc_relationship_GetSourceUri(IOpcRelationship *iface, IOpcUri **uri)
1119 {
1120     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1121
1122     TRACE("iface %p, uri %p.\n", iface, uri);
1123
1124     *uri = relationship->source_uri;
1125     IOpcUri_AddRef(*uri);
1126
1127     return S_OK;
1128 }
1129
1130 static HRESULT WINAPI opc_relationship_GetTargetUri(IOpcRelationship *iface, IUri **target)
1131 {
1132     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1133
1134     TRACE("iface %p, target %p.\n", iface, target);
1135
1136     *target = relationship->target;
1137     IUri_AddRef(*target);
1138
1139     return S_OK;
1140 }
1141
1142 static HRESULT WINAPI opc_relationship_GetTargetMode(IOpcRelationship *iface, OPC_URI_TARGET_MODE *target_mode)
1143 {
1144     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1145
1146     TRACE("iface %p, target_mode %p.\n", iface, target_mode);
1147
1148     *target_mode = relationship->target_mode;
1149
1150     return S_OK;
1151 }
1152
1153 static const IOpcRelationshipVtbl opc_relationship_vtbl =
1154 {
1155     opc_relationship_QueryInterface,
1156     opc_relationship_AddRef,
1157     opc_relationship_Release,
1158     opc_relationship_GetId,
1159     opc_relationship_GetRelationshipType,
1160     opc_relationship_GetSourceUri,
1161     opc_relationship_GetTargetUri,
1162     opc_relationship_GetTargetMode,
1163 };
1164
1165 static struct opc_relationship *opc_relationshipset_get_rel(struct opc_relationship_set *relationship_set,
1166         const WCHAR *id)
1167 {
1168     size_t i;
1169
1170     for (i = 0; i < relationship_set->count; i++)
1171     {
1172         if (!strcmpW(id, relationship_set->relationships[i]->id))
1173             return relationship_set->relationships[i];
1174     }
1175
1176     return NULL;
1177 }
1178
1179 static HRESULT opc_relationship_create(struct opc_relationship_set *set, const WCHAR *id, const WCHAR *type,
1180         IUri *target_uri, OPC_URI_TARGET_MODE target_mode, IOpcRelationship **out)
1181 {
1182     struct opc_relationship *relationship;
1183
1184     if (!opc_array_reserve((void **)&set->relationships, &set->size, set->count + 1, sizeof(*set->relationships)))
1185         return E_OUTOFMEMORY;
1186
1187     if (!(relationship = heap_alloc_zero(sizeof(*relationship))))
1188         return E_OUTOFMEMORY;
1189
1190     relationship->IOpcRelationship_iface.lpVtbl = &opc_relationship_vtbl;
1191     relationship->refcount = 1;
1192
1193     relationship->target = target_uri;
1194     IUri_AddRef(relationship->target);
1195     relationship->source_uri = set->source_uri;
1196     IOpcUri_AddRef(relationship->source_uri);
1197
1198     if (id)
1199         relationship->id = opc_strdupW(id);
1200     else
1201     {
1202         relationship->id = CoTaskMemAlloc(10 * sizeof(WCHAR));
1203         if (relationship->id)
1204         {
1205             static const WCHAR fmtW[] = {'R','%','0','8','X',0};
1206             DWORD generated;
1207
1208             /* FIXME: test that generated id is unique */
1209             RtlGenRandom(&generated, sizeof(generated));
1210             sprintfW(relationship->id, fmtW, generated);
1211
1212             if (opc_relationshipset_get_rel(set, relationship->id))
1213             {
1214                 WARN("Newly generated id %s already exists.\n", debugstr_w(relationship->id));
1215                 IOpcRelationship_Release(&relationship->IOpcRelationship_iface);
1216                 return E_FAIL;
1217             }
1218         }
1219     }
1220
1221     relationship->type = opc_strdupW(type);
1222     if (!relationship->id || !relationship->type)
1223     {
1224         IOpcRelationship_Release(&relationship->IOpcRelationship_iface);
1225         return E_OUTOFMEMORY;
1226     }
1227
1228     set->relationships[set->count++] = relationship;
1229     IOpcRelationship_AddRef(&relationship->IOpcRelationship_iface);
1230     CoCreateGuid(&set->id);
1231
1232     *out = &relationship->IOpcRelationship_iface;
1233     TRACE("Created relationship %p.\n", *out);
1234     return S_OK;
1235 }
1236
1237 static HRESULT WINAPI opc_relationship_set_QueryInterface(IOpcRelationshipSet *iface, REFIID iid, void **out)
1238 {
1239     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
1240
1241     if (IsEqualIID(iid, &IID_IOpcRelationshipSet) ||
1242             IsEqualIID(iid, &IID_IUnknown))
1243     {
1244         *out = iface;
1245         IOpcRelationshipSet_AddRef(iface);
1246         return S_OK;
1247     }
1248
1249     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
1250     return E_NOINTERFACE;
1251 }
1252
1253 static ULONG WINAPI opc_relationship_set_AddRef(IOpcRelationshipSet *iface)
1254 {
1255     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1256     ULONG refcount = InterlockedIncrement(&relationship_set->refcount);
1257
1258     TRACE("%p increasing refcount to %u.\n", iface, refcount);
1259
1260     return refcount;
1261 }
1262
1263 static ULONG WINAPI opc_relationship_set_Release(IOpcRelationshipSet *iface)
1264 {
1265     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1266     ULONG refcount = InterlockedDecrement(&relationship_set->refcount);
1267
1268     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
1269
1270     if (!refcount)
1271     {
1272         size_t i;
1273
1274         for (i = 0; i < relationship_set->count; ++i)
1275             IOpcRelationship_Release(&relationship_set->relationships[i]->IOpcRelationship_iface);
1276         IOpcUri_Release(relationship_set->source_uri);
1277         heap_free(relationship_set->relationships);
1278         heap_free(relationship_set);
1279     }
1280
1281     return refcount;
1282 }
1283
1284 static HRESULT WINAPI opc_relationship_set_GetRelationship(IOpcRelationshipSet *iface, const WCHAR *id,
1285         IOpcRelationship **relationship)
1286 {
1287     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1288     struct opc_relationship *ret;
1289
1290     TRACE("iface %p, id %s, relationship %p.\n", iface, debugstr_w(id), relationship);
1291
1292     if (!relationship)
1293         return E_POINTER;
1294
1295     *relationship = NULL;
1296
1297     if (!id)
1298         return E_POINTER;
1299
1300     if ((ret = opc_relationshipset_get_rel(relationship_set, id)))
1301     {
1302         *relationship = &ret->IOpcRelationship_iface;
1303         IOpcRelationship_AddRef(*relationship);
1304     }
1305
1306     return *relationship ? S_OK : OPC_E_NO_SUCH_RELATIONSHIP;
1307 }
1308
1309 static HRESULT WINAPI opc_relationship_set_CreateRelationship(IOpcRelationshipSet *iface, const WCHAR *id,
1310         const WCHAR *type, IUri *target_uri, OPC_URI_TARGET_MODE target_mode, IOpcRelationship **relationship)
1311 {
1312     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1313     DWORD length;
1314
1315     TRACE("iface %p, id %s, type %s, target_uri %p, target_mode %d, relationship %p.\n", iface, debugstr_w(id),
1316             debugstr_w(type), target_uri, target_mode, relationship);
1317
1318     if (!relationship)
1319         return E_POINTER;
1320
1321     *relationship = NULL;
1322
1323     if (!type || !target_uri)
1324         return E_POINTER;
1325
1326     if (id && opc_relationshipset_get_rel(relationship_set, id))
1327         return OPC_E_DUPLICATE_RELATIONSHIP;
1328
1329     if (IUri_GetPropertyLength(target_uri, Uri_PROPERTY_SCHEME_NAME, &length, 0) == S_OK && length != 0
1330             && target_mode == OPC_URI_TARGET_MODE_INTERNAL)
1331         return OPC_E_INVALID_RELATIONSHIP_TARGET;
1332
1333     return opc_relationship_create(relationship_set, id, type, target_uri, target_mode, relationship);
1334 }
1335
1336 static HRESULT WINAPI opc_relationship_set_DeleteRelationship(IOpcRelationshipSet *iface, const WCHAR *id)
1337 {
1338     FIXME("iface %p, id %s stub!\n", iface, debugstr_w(id));
1339
1340     return E_NOTIMPL;
1341 }
1342
1343 static HRESULT WINAPI opc_relationship_set_RelationshipExists(IOpcRelationshipSet *iface, const WCHAR *id, BOOL *exists)
1344 {
1345     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1346
1347     TRACE("iface %p, id %s, exists %p.\n", iface, debugstr_w(id), exists);
1348
1349     if (!id || !exists)
1350         return E_POINTER;
1351
1352     *exists = opc_relationshipset_get_rel(relationship_set, id) != NULL;
1353
1354     return S_OK;
1355 }
1356
1357 static HRESULT WINAPI opc_relationship_set_GetEnumerator(IOpcRelationshipSet *iface,
1358         IOpcRelationshipEnumerator **enumerator)
1359 {
1360     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1361
1362     TRACE("iface %p, enumerator %p.\n", iface, enumerator);
1363
1364     if (!enumerator)
1365         return E_POINTER;
1366
1367     return opc_rel_enum_create(relationship_set, enumerator);
1368 }
1369
1370 static HRESULT WINAPI opc_relationship_set_GetEnumeratorForType(IOpcRelationshipSet *iface, const WCHAR *type,
1371         IOpcRelationshipEnumerator **enumerator)
1372 {
1373     FIXME("iface %p, type %s, enumerator %p stub!\n", iface, debugstr_w(type), enumerator);
1374
1375     return E_NOTIMPL;
1376 }
1377
1378 static HRESULT WINAPI opc_relationship_set_GetRelationshipsContentStream(IOpcRelationshipSet *iface, IStream **stream)
1379 {
1380     FIXME("iface %p, stream %p stub!\n", iface, stream);
1381
1382     return E_NOTIMPL;
1383 }
1384
1385 static const IOpcRelationshipSetVtbl opc_relationship_set_vtbl =
1386 {
1387     opc_relationship_set_QueryInterface,
1388     opc_relationship_set_AddRef,
1389     opc_relationship_set_Release,
1390     opc_relationship_set_GetRelationship,
1391     opc_relationship_set_CreateRelationship,
1392     opc_relationship_set_DeleteRelationship,
1393     opc_relationship_set_RelationshipExists,
1394     opc_relationship_set_GetEnumerator,
1395     opc_relationship_set_GetEnumeratorForType,
1396     opc_relationship_set_GetRelationshipsContentStream,
1397 };
1398
1399 static HRESULT opc_relationship_set_create(IOpcUri *source_uri, IOpcRelationshipSet **out)
1400 {
1401     struct opc_relationship_set *relationship_set;
1402
1403     if (!(relationship_set = heap_alloc_zero(sizeof(*relationship_set))))
1404         return E_OUTOFMEMORY;
1405
1406     relationship_set->IOpcRelationshipSet_iface.lpVtbl = &opc_relationship_set_vtbl;
1407     relationship_set->refcount = 1;
1408     relationship_set->source_uri = source_uri;
1409     IOpcUri_AddRef(relationship_set->source_uri);
1410
1411     *out = &relationship_set->IOpcRelationshipSet_iface;
1412     TRACE("Created relationship set %p.\n", *out);
1413     return S_OK;
1414 }
1415
1416 static HRESULT WINAPI opc_package_QueryInterface(IOpcPackage *iface, REFIID iid, void **out)
1417 {
1418     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
1419
1420     if (IsEqualIID(iid, &IID_IOpcPackage) ||
1421             IsEqualIID(iid, &IID_IUnknown))
1422     {
1423         *out = iface;
1424         IOpcPackage_AddRef(iface);
1425         return S_OK;
1426     }
1427
1428     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
1429     return E_NOINTERFACE;
1430 }
1431
1432 static ULONG WINAPI opc_package_AddRef(IOpcPackage *iface)
1433 {
1434     struct opc_package *package = impl_from_IOpcPackage(iface);
1435     ULONG refcount = InterlockedIncrement(&package->refcount);
1436
1437     TRACE("%p increasing refcount to %u.\n", iface, refcount);
1438
1439     return refcount;
1440 }
1441
1442 static ULONG WINAPI opc_package_Release(IOpcPackage *iface)
1443 {
1444     struct opc_package *package = impl_from_IOpcPackage(iface);
1445     ULONG refcount = InterlockedDecrement(&package->refcount);
1446
1447     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
1448
1449     if (!refcount)
1450     {
1451         if (package->part_set)
1452             IOpcPartSet_Release(package->part_set);
1453         if (package->relationship_set)
1454             IOpcRelationshipSet_Release(package->relationship_set);
1455         if (package->source_uri)
1456             IOpcUri_Release(package->source_uri);
1457         heap_free(package);
1458     }
1459
1460     return refcount;
1461 }
1462
1463 static HRESULT WINAPI opc_package_GetPartSet(IOpcPackage *iface, IOpcPartSet **part_set)
1464 {
1465     struct opc_package *package = impl_from_IOpcPackage(iface);
1466
1467     TRACE("iface %p, part_set %p.\n", iface, part_set);
1468
1469     if (!package->part_set)
1470     {
1471         struct opc_part_set *part_set = heap_alloc_zero(sizeof(*part_set));
1472         if (!part_set)
1473             return E_OUTOFMEMORY;
1474
1475         part_set->IOpcPartSet_iface.lpVtbl = &opc_part_set_vtbl;
1476         part_set->refcount = 1;
1477
1478         package->part_set = &part_set->IOpcPartSet_iface;
1479     }
1480
1481     *part_set = package->part_set;
1482     IOpcPartSet_AddRef(*part_set);
1483
1484     return S_OK;
1485 }
1486
1487 static HRESULT WINAPI opc_package_GetRelationshipSet(IOpcPackage *iface, IOpcRelationshipSet **relationship_set)
1488 {
1489     struct opc_package *package = impl_from_IOpcPackage(iface);
1490     HRESULT hr;
1491
1492     TRACE("iface %p, relationship_set %p.\n", iface, relationship_set);
1493
1494     if (!package->relationship_set)
1495     {
1496         if (FAILED(hr = opc_relationship_set_create(package->source_uri, &package->relationship_set)))
1497             return hr;
1498     }
1499
1500     *relationship_set = package->relationship_set;
1501     IOpcRelationshipSet_AddRef(*relationship_set);
1502
1503     return S_OK;
1504 }
1505
1506 static const IOpcPackageVtbl opc_package_vtbl =
1507 {
1508     opc_package_QueryInterface,
1509     opc_package_AddRef,
1510     opc_package_Release,
1511     opc_package_GetPartSet,
1512     opc_package_GetRelationshipSet,
1513 };
1514
1515 HRESULT opc_package_create(IOpcFactory *factory, IOpcPackage **out)
1516 {
1517     struct opc_package *package;
1518     HRESULT hr;
1519
1520     if (!(package = heap_alloc_zero(sizeof(*package))))
1521         return E_OUTOFMEMORY;
1522
1523     package->IOpcPackage_iface.lpVtbl = &opc_package_vtbl;
1524     package->refcount = 1;
1525
1526     if (FAILED(hr = IOpcFactory_CreatePackageRootUri(factory, &package->source_uri)))
1527     {
1528         heap_free(package);
1529         return hr;
1530     }
1531
1532     *out = &package->IOpcPackage_iface;
1533     TRACE("Created package %p.\n", *out);
1534     return S_OK;
1535 }
1536
1537 struct content_types
1538 {
1539     struct list types;
1540     BOOL has_rels_part;
1541 };
1542
1543 enum content_type_element
1544 {
1545     CONTENT_TYPE_DEFAULT,
1546     CONTENT_TYPE_OVERRIDE,
1547 };
1548
1549 struct content_type
1550 {
1551     struct list entry;
1552     enum content_type_element element;
1553     union
1554     {
1555         struct default_type
1556         {
1557             WCHAR *ext;
1558             WCHAR *type;
1559         } def;
1560         struct override_type
1561         {
1562             IOpcPart *part;
1563         } override;
1564     } u;
1565 };
1566
1567 static HRESULT opc_package_add_override_content_type(struct content_types *types, IOpcPart *part)
1568 {
1569     struct content_type *type;
1570
1571     if (!(type = heap_alloc(sizeof(*type))))
1572         return E_OUTOFMEMORY;
1573
1574     type->element = CONTENT_TYPE_OVERRIDE;
1575     type->u.override.part = part;
1576     IOpcPart_AddRef(part);
1577
1578     list_add_tail(&types->types, &type->entry);
1579
1580     return S_OK;
1581 }
1582
1583 static HRESULT opc_package_add_default_content_type(struct content_types *types,
1584         const WCHAR *ext, const WCHAR *content_type)
1585 {
1586     struct content_type *type;
1587
1588     if (!(type = heap_alloc(sizeof(*type))))
1589         return E_OUTOFMEMORY;
1590
1591     type->element = CONTENT_TYPE_DEFAULT;
1592     type->u.def.ext = opc_strdupW(ext);
1593     type->u.def.type = opc_strdupW(content_type);
1594     if (!type->u.def.ext || !type->u.def.type)
1595     {
1596         CoTaskMemFree(type->u.def.ext);
1597         CoTaskMemFree(type->u.def.type);
1598         heap_free(type);
1599         return E_OUTOFMEMORY;
1600     }
1601
1602     list_add_tail(&types->types, &type->entry);
1603
1604     return S_OK;
1605 }
1606
1607 static HRESULT opc_package_add_content_type(struct content_types *types, IOpcPart *part)
1608 {
1609     struct content_type *cur;
1610     BSTR ext, content_type;
1611     BOOL added = FALSE;
1612     IOpcPartUri *name;
1613     HRESULT hr;
1614
1615     if (FAILED(hr = IOpcPart_GetName(part, &name)))
1616         return hr;
1617
1618     hr = IOpcPartUri_GetExtension(name, &ext);
1619     IOpcPartUri_Release(name);
1620     if (hr == S_FALSE)
1621     {
1622         hr = opc_package_add_override_content_type(types, part);
1623         SysFreeString(ext);
1624         return hr;
1625     }
1626
1627     if (FAILED(hr))
1628         return hr;
1629
1630     if (FAILED(hr = IOpcPart_GetContentType(part, &content_type)))
1631         return hr;
1632
1633     LIST_FOR_EACH_ENTRY(cur, &types->types, struct content_type, entry)
1634     {
1635         if (cur->element == CONTENT_TYPE_OVERRIDE)
1636             continue;
1637
1638         if (!strcmpiW(cur->u.def.ext, ext))
1639         {
1640             added = TRUE;
1641
1642             if (!strcmpW(cur->u.def.type, content_type))
1643                 break;
1644
1645             hr = opc_package_add_override_content_type(types, part);
1646             break;
1647         }
1648     }
1649
1650     if (!added)
1651         hr = opc_package_add_default_content_type(types, ext, content_type);
1652
1653     SysFreeString(ext);
1654     SysFreeString(content_type);
1655
1656     return hr;
1657 }
1658
1659 static BOOL opc_package_has_rels_part(IOpcRelationshipSet *rel_set)
1660 {
1661     IOpcRelationshipEnumerator *enumerator;
1662     BOOL has_next;
1663     HRESULT hr;
1664
1665     if (FAILED(hr = IOpcRelationshipSet_GetEnumerator(rel_set, &enumerator)))
1666         return FALSE;
1667
1668     has_next = FALSE;
1669     IOpcRelationshipEnumerator_MoveNext(enumerator, &has_next);
1670     IOpcRelationshipEnumerator_Release(enumerator);
1671
1672     return has_next;
1673 }
1674
1675 static HRESULT opc_package_collect_content_types(IOpcPackage *package, struct content_types *types)
1676 {
1677     IOpcPartEnumerator *enumerator;
1678     IOpcRelationshipSet *rel_set;
1679     IOpcPartSet *parts;
1680     BOOL has_next;
1681     HRESULT hr;
1682
1683     if (FAILED(hr = IOpcPackage_GetPartSet(package, &parts)))
1684         return hr;
1685
1686     hr = IOpcPackage_GetRelationshipSet(package, &rel_set);
1687     if (SUCCEEDED(hr))
1688     {
1689         types->has_rels_part |= opc_package_has_rels_part(rel_set);
1690         IOpcRelationshipSet_Release(rel_set);
1691     }
1692
1693     hr = IOpcPartSet_GetEnumerator(parts, &enumerator);
1694     IOpcPartSet_Release(parts);
1695     if (FAILED(hr))
1696         return hr;
1697
1698     if (FAILED(hr = IOpcPartEnumerator_MoveNext(enumerator, &has_next)) || !has_next)
1699     {
1700         IOpcPartEnumerator_Release(enumerator);
1701         return hr;
1702     }
1703
1704     while (has_next)
1705     {
1706         IOpcPart *part;
1707
1708         if (FAILED(hr = IOpcPartEnumerator_GetCurrent(enumerator, &part)))
1709             break;
1710
1711         if (!types->has_rels_part)
1712         {
1713             hr = IOpcPart_GetRelationshipSet(part, &rel_set);
1714             if (SUCCEEDED(hr))
1715             {
1716                 types->has_rels_part |= opc_package_has_rels_part(rel_set);
1717                 IOpcRelationshipSet_Release(rel_set);
1718             }
1719         }
1720
1721         hr = opc_package_add_content_type(types, part);
1722         IOpcPart_Release(part);
1723         if (FAILED(hr))
1724             break;
1725
1726         if (FAILED(hr = IOpcPartEnumerator_MoveNext(enumerator, &has_next)))
1727             break;
1728     }
1729
1730     IOpcPartEnumerator_Release(enumerator);
1731
1732     return hr;
1733 }
1734
1735 static HRESULT opc_package_write_default_type(const WCHAR *ext, const WCHAR *type, IXmlWriter *writer)
1736 {
1737     static const WCHAR contenttypeW[] = {'C','o','n','t','e','n','t','T','y','p','e',0};
1738     static const WCHAR extensionW[] = {'E','x','t','e','n','s','i','o','n',0};
1739     static const WCHAR defaultW[] = {'D','e','f','a','u','l','t',0};
1740     HRESULT hr;
1741
1742     hr = IXmlWriter_WriteStartElement(writer, NULL, defaultW, NULL);
1743     if (SUCCEEDED(hr))
1744         hr = IXmlWriter_WriteAttributeString(writer, NULL, extensionW, NULL, ext);
1745     if (SUCCEEDED(hr))
1746         hr = IXmlWriter_WriteAttributeString(writer, NULL, contenttypeW, NULL, type);
1747     return hr;
1748 }
1749
1750 static HRESULT opc_package_write_contenttypes(IOpcPackage *package, struct zip_archive *archive, IXmlWriter *writer)
1751 {
1752     static const WCHAR uriW[] = {'h','t','t','p',':','/','/','s','c','h','e','m','a','s','.','o','p','e','n','x','m','l','f','o','r','m','a','t','s','.','o','r','g','/',
1753             'p','a','c','k','a','g','e','/','2','0','0','6','/','c','o','n','t','e','n','t','-','t','y','p','e','s',0};
1754     static const WCHAR relstypeW[] = {'a','p','p','l','i','c','a','t','i','o','n','/','v','n','d','.','o','p','e','n','x','m','l','f','o','r','m','a','t','s','-',
1755             'p','a','c','k','a','g','e','.','r','e','l','a','t','i','o','n','s','h','i','p','s','+','x','m','l',0};
1756     static const WCHAR contenttypesW[] = {'[','C','o','n','t','e','n','t','_','T','y','p','e','s',']','.','x','m','l',0};
1757     static const WCHAR contenttypeW[] = {'C','o','n','t','e','n','t','T','y','p','e',0};
1758     static const WCHAR overrideW[] = {'O','v','e','r','r','i','d','e',0};
1759     static const WCHAR partnameW[] = {'P','a','r','t','N','a','m','e',0};
1760     static const WCHAR typesW[] = {'T','y','p','e','s',0};
1761     static const WCHAR relsW[] = {'r','e','l','s',0};
1762     struct content_type *content_type, *content_type2;
1763     struct content_types types;
1764     IStream *content = NULL;
1765     HRESULT hr;
1766
1767     list_init(&types.types);
1768     types.has_rels_part = FALSE;
1769
1770     hr = CreateStreamOnHGlobal(NULL, TRUE, &content);
1771     if (SUCCEEDED(hr))
1772         hr = opc_package_collect_content_types(package, &types);
1773     if (SUCCEEDED(hr))
1774         hr = IXmlWriter_SetOutput(writer, (IUnknown *)content);
1775     if (SUCCEEDED(hr))
1776         hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Omit);
1777     if (SUCCEEDED(hr))
1778         hr = IXmlWriter_WriteStartElement(writer, NULL, typesW, uriW);
1779
1780     if (SUCCEEDED(hr) && types.has_rels_part)
1781     {
1782         hr = opc_package_write_default_type(relsW, relstypeW, writer);
1783         if (SUCCEEDED(hr))
1784             hr = IXmlWriter_WriteEndElement(writer);
1785     }
1786
1787     LIST_FOR_EACH_ENTRY_SAFE(content_type, content_type2, &types.types, struct content_type, entry)
1788     {
1789         if (content_type->element == CONTENT_TYPE_DEFAULT)
1790         {
1791             hr = opc_package_write_default_type(content_type->u.def.ext + 1, content_type->u.def.type, writer);
1792
1793             CoTaskMemFree(content_type->u.def.ext);
1794             CoTaskMemFree(content_type->u.def.type);
1795         }
1796         else
1797         {
1798             IOpcPartUri *uri = NULL;
1799             WCHAR *type = NULL;
1800             BSTR name = NULL;
1801
1802             if (SUCCEEDED(hr))
1803                 hr = IXmlWriter_WriteStartElement(writer, NULL, overrideW, NULL);
1804             if (SUCCEEDED(hr))
1805                 hr = IOpcPart_GetName(content_type->u.override.part, &uri);
1806             if (SUCCEEDED(hr))
1807                 hr = IOpcPartUri_GetRawUri(uri, &name);
1808             if (SUCCEEDED(hr))
1809                 hr = IXmlWriter_WriteAttributeString(writer, NULL, partnameW, NULL, name);
1810             if (SUCCEEDED(hr))
1811                 hr = IOpcPart_GetContentType(content_type->u.override.part, &type);
1812             if (SUCCEEDED(hr))
1813                 hr = IXmlWriter_WriteAttributeString(writer, NULL, contenttypeW, NULL, type);
1814
1815             if (uri)
1816                 IOpcPartUri_Release(uri);
1817             SysFreeString(name);
1818             CoTaskMemFree(type);
1819
1820             IOpcPart_Release(content_type->u.override.part);
1821         }
1822         if (SUCCEEDED(hr))
1823             hr = IXmlWriter_WriteEndElement(writer);
1824
1825         list_remove(&content_type->entry);
1826         heap_free(content_type);
1827     }
1828
1829     if (SUCCEEDED(hr))
1830         hr = IXmlWriter_WriteEndDocument(writer);
1831     if (SUCCEEDED(hr))
1832         hr = IXmlWriter_Flush(writer);
1833
1834     if (SUCCEEDED(hr))
1835         hr = compress_add_file(archive, contenttypesW, content, OPC_COMPRESSION_NORMAL);
1836
1837     if (content)
1838         IStream_Release(content);
1839
1840     return hr;
1841 }
1842
1843 static HRESULT opc_package_write_rel(IOpcRelationship *rel, IXmlWriter *writer)
1844 {
1845     static const WCHAR relationshipW[] = {'R','e','l','a','t','i','o','n','s','h','i','p',0};
1846     static const WCHAR targetW[] = {'T','a','r','g','e','t',0};
1847     static const WCHAR typeW[] = {'T','y','p','e',0};
1848     static const WCHAR idW[] = {'I','d',0};
1849     BSTR target_uri;
1850     HRESULT hr;
1851     WCHAR *str;
1852     IUri *uri;
1853
1854     if (FAILED(hr = IXmlWriter_WriteStartElement(writer, NULL, relationshipW, NULL)))
1855         return hr;
1856
1857     if (FAILED(hr = IOpcRelationship_GetTargetUri(rel, &uri)))
1858         return hr;
1859
1860     IUri_GetRawUri(uri, &target_uri);
1861     IUri_Release(uri);
1862
1863     hr = IXmlWriter_WriteAttributeString(writer, NULL, targetW, NULL, target_uri);
1864     SysFreeString(target_uri);
1865     if (FAILED(hr))
1866         return hr;
1867
1868     if (FAILED(hr = IOpcRelationship_GetId(rel, &str)))
1869         return hr;
1870
1871     hr = IXmlWriter_WriteAttributeString(writer, NULL, idW, NULL, str);
1872     CoTaskMemFree(str);
1873     if (FAILED(hr))
1874         return hr;
1875
1876     if (FAILED(hr = IOpcRelationship_GetRelationshipType(rel, &str)))
1877         return hr;
1878
1879     hr = IXmlWriter_WriteAttributeString(writer, NULL, typeW, NULL, str);
1880     CoTaskMemFree(str);
1881     if (FAILED(hr))
1882         return hr;
1883
1884     return IXmlWriter_WriteEndElement(writer);
1885 }
1886
1887 static HRESULT opc_package_write_rels(struct zip_archive *archive, IOpcRelationshipSet *rels,
1888         IOpcUri *uri, IXmlWriter *writer)
1889 {
1890     static const WCHAR uriW[] = {'h','t','t','p',':','/','/','s','c','h','e','m','a','s','.','o','p','e','n','x','m','l','f','o','r','m','a','t','s','.','o','r','g','/',
1891             'p','a','c','k','a','g','e','/','2','0','0','6','/','r','e','l','a','t','i','o','n','s','h','i','p','s',0};
1892     static const WCHAR relationshipsW[] = {'R','e','l','a','t','i','o','n','s','h','i','p','s',0};
1893     IOpcRelationshipEnumerator *enumerator;
1894     IOpcPartUri *rels_uri;
1895     BSTR rels_part_uri;
1896     IStream *content;
1897     BOOL has_next;
1898     HRESULT hr;
1899
1900     if (FAILED(hr = IOpcRelationshipSet_GetEnumerator(rels, &enumerator)))
1901         return hr;
1902
1903     hr = IOpcRelationshipEnumerator_MoveNext(enumerator, &has_next);
1904     if (!has_next)
1905     {
1906         IOpcRelationshipEnumerator_Release(enumerator);
1907         return hr;
1908     }
1909
1910     if (FAILED(hr = CreateStreamOnHGlobal(NULL, TRUE, &content)))
1911     {
1912         IOpcRelationshipEnumerator_Release(enumerator);
1913         return hr;
1914     }
1915
1916     hr = IXmlWriter_SetOutput(writer, (IUnknown *)content);
1917     if (SUCCEEDED(hr))
1918         hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
1919     if (SUCCEEDED(hr))
1920         hr = IXmlWriter_WriteStartElement(writer, NULL, relationshipsW, uriW);
1921
1922     while (has_next)
1923     {
1924         IOpcRelationship *rel;
1925
1926         if (FAILED(hr = IOpcRelationshipEnumerator_GetCurrent(enumerator, &rel)))
1927             break;
1928
1929         hr = opc_package_write_rel(rel, writer);
1930         IOpcRelationship_Release(rel);
1931         if (FAILED(hr))
1932             break;
1933
1934         IOpcRelationshipEnumerator_MoveNext(enumerator, &has_next);
1935     }
1936
1937     IOpcRelationshipEnumerator_Release(enumerator);
1938
1939     if (SUCCEEDED(hr))
1940         hr = IXmlWriter_WriteEndDocument(writer);
1941     if (SUCCEEDED(hr))
1942         hr = IXmlWriter_Flush(writer);
1943
1944     if (SUCCEEDED(hr))
1945         hr = IOpcUri_GetRelationshipsPartUri(uri, &rels_uri);
1946     if (SUCCEEDED(hr))
1947         hr = IOpcPartUri_GetRawUri(rels_uri, &rels_part_uri);
1948     if (SUCCEEDED(hr))
1949     {
1950         /* Relationship part names always start with root '/', skip it. */
1951         hr = compress_add_file(archive, rels_part_uri + 1, content, OPC_COMPRESSION_NORMAL);
1952     }
1953
1954     SysFreeString(rels_part_uri);
1955     IStream_Release(content);
1956
1957     return hr;
1958 }
1959
1960 static HRESULT opc_package_write_part(struct zip_archive *archive, IOpcPart *part, IXmlWriter *writer)
1961 {
1962     OPC_COMPRESSION_OPTIONS options = OPC_COMPRESSION_NORMAL;
1963     IOpcRelationshipSet *rels = NULL;
1964     IStream *content = NULL;
1965     IOpcPartUri *name;
1966     BSTR uri = NULL;
1967     HRESULT hr;
1968
1969     if (FAILED(hr = IOpcPart_GetName(part, &name)))
1970         return hr;
1971
1972     hr = IOpcPartUri_GetRawUri(name, &uri);
1973     if (SUCCEEDED(hr))
1974         hr = IOpcPart_GetCompressionOptions(part, &options);
1975     if (SUCCEEDED(hr))
1976         hr = IOpcPart_GetContentStream(part, &content);
1977     if (SUCCEEDED(hr))
1978     {
1979         /* Part names always start with root '/', skip it. */
1980         hr = compress_add_file(archive, uri + 1, content, options);
1981     }
1982     if (SUCCEEDED(hr))
1983         hr = IOpcPart_GetRelationshipSet(part, &rels);
1984     if (SUCCEEDED(hr))
1985         hr = opc_package_write_rels(archive, rels, (IOpcUri *)name, writer);
1986
1987     IOpcPartUri_Release(name);
1988     SysFreeString(uri);
1989     if (content)
1990         IStream_Release(content);
1991     if (rels)
1992         IOpcRelationshipSet_Release(rels);
1993
1994     return hr;
1995 }
1996
1997 static HRESULT opc_package_write_parts(struct zip_archive *archive, IOpcPackage *package, IXmlWriter *writer)
1998 {
1999     IOpcPartEnumerator *parts;
2000     IOpcPartSet *part_set;
2001     BOOL got_next;
2002     HRESULT hr;
2003
2004     if (FAILED(hr = IOpcPackage_GetPartSet(package, &part_set)))
2005         return hr;
2006
2007     hr = IOpcPartSet_GetEnumerator(part_set, &parts);
2008     IOpcPartSet_Release(part_set);
2009     if (FAILED(hr))
2010         return hr;
2011
2012     while (IOpcPartEnumerator_MoveNext(parts, &got_next) == S_OK && got_next)
2013     {
2014         IOpcPart *part;
2015
2016         if (FAILED(hr = IOpcPartEnumerator_GetCurrent(parts, &part)))
2017             break;
2018
2019         hr = opc_package_write_part(archive, part, writer);
2020         IOpcPart_Release(part);
2021         if (FAILED(hr))
2022             break;
2023     }
2024
2025     IOpcPartEnumerator_Release(parts);
2026
2027     return hr;
2028 }
2029
2030 HRESULT opc_package_write(IOpcPackage *package, OPC_WRITE_FLAGS flags, IStream *stream)
2031 {
2032     IOpcRelationshipSet *rels = NULL;
2033     struct zip_archive *archive;
2034     IOpcUri *uri = NULL;
2035     IXmlWriter *writer;
2036     HRESULT hr;
2037
2038     if (flags != OPC_WRITE_FORCE_ZIP32)
2039         FIXME("Unsupported write flags %#x.\n", flags);
2040
2041     if (FAILED(hr = CreateXmlWriter(&IID_IXmlWriter, (void **)&writer, NULL)))
2042         return hr;
2043
2044     if (FAILED(hr = compress_create_archive(stream, &archive)))
2045     {
2046         IXmlWriter_Release(writer);
2047         return hr;
2048     }
2049
2050     /* [Content_Types].xml */
2051     hr = opc_package_write_contenttypes(package, archive, writer);
2052     /* Package relationships. */
2053     if (SUCCEEDED(hr))
2054         hr = IOpcPackage_GetRelationshipSet(package, &rels);
2055     if (SUCCEEDED(hr))
2056         hr = opc_root_uri_create(&uri);
2057     if (SUCCEEDED(hr))
2058         hr = opc_package_write_rels(archive, rels, uri, writer);
2059     /* Parts. */
2060     if (SUCCEEDED(hr))
2061         hr = opc_package_write_parts(archive, package, writer);
2062
2063     if (rels)
2064         IOpcRelationshipSet_Release(rels);
2065     if (uri)
2066         IOpcUri_Release(uri);
2067
2068     compress_finalize_archive(archive);
2069     IXmlWriter_Release(writer);
2070
2071     return hr;
2072 }