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