support updated xio_open definition

damonbarry · damonbarry · commit 1b13a97bcbd2 · 2016-02-29T17:03:43.000-08:00
diff --git a/azure-c-shared-utility b/azure-c-shared-utility
@@ -1 +1 @@
-Subproject commit ca4199dabd8fced8043cbef1edff6556e0cd4f15
+Subproject commit d7f09fbbceeac3c3db2c20a52041f4c95409d9ac
diff --git a/inc/header_detect_io.h b/inc/header_detect_io.h
@@ -17,7 +17,7 @@ extern "C" {
 
 	extern CONCRETE_IO_HANDLE headerdetectio_create(void* io_create_parameters, LOGGER_LOG logger_log);
 	extern void headerdetectio_destroy(CONCRETE_IO_HANDLE header_detect_io);
-	extern int headerdetectio_open(CONCRETE_IO_HANDLE header_detect_io, ON_IO_OPEN_COMPLETE on_io_open_complete, ON_BYTES_RECEIVED on_bytes_received, ON_IO_ERROR on_io_error, void* callback_context);
+	extern int headerdetectio_open(CONCRETE_IO_HANDLE header_detect_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context);
 	extern int headerdetectio_close(CONCRETE_IO_HANDLE header_detect_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context);
 	extern int headerdetectio_send(CONCRETE_IO_HANDLE header_detect_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context);
 	extern void headerdetectio_dowork(CONCRETE_IO_HANDLE header_detect_io);
diff --git a/inc/saslclientio.h b/inc/saslclientio.h
@@ -23,7 +23,7 @@ typedef struct SASLCLIENTIO_CONFIG_TAG
 
 extern CONCRETE_IO_HANDLE saslclientio_create(void* io_create_parameters, LOGGER_LOG logger_log);
 extern void saslclientio_destroy(CONCRETE_IO_HANDLE sasl_client_io);
-extern int saslclientio_open(CONCRETE_IO_HANDLE sasl_client_io, ON_IO_OPEN_COMPLETE on_io_open_complete, ON_BYTES_RECEIVED on_bytes_received, ON_IO_ERROR on_io_error, void* callback_context);
+extern int saslclientio_open(CONCRETE_IO_HANDLE sasl_client_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context);
 extern int saslclientio_close(CONCRETE_IO_HANDLE sasl_client_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context);
 extern int saslclientio_send(CONCRETE_IO_HANDLE sasl_client_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context);
 extern void saslclientio_dowork(CONCRETE_IO_HANDLE sasl_client_io);
diff --git a/src/connection.c b/src/connection.c
@@ -1016,7 +1016,7 @@ int connection_open(CONNECTION_HANDLE connection)
 	{
 		if (!connection->is_underlying_io_open)
 		{
-			if (xio_open(connection->io, connection_on_io_open_complete, connection_on_bytes_received, connection_on_io_error, connection) != 0)
+			if (xio_open(connection->io, connection_on_io_open_complete, connection, connection_on_bytes_received, connection, connection_on_io_error, connection) != 0)
 			{
 				connection_set_state(connection, CONNECTION_STATE_END);
 				result = __LINE__;
@@ -1051,7 +1051,7 @@ int connection_listen(CONNECTION_HANDLE connection)
 	{
 		if (!connection->is_underlying_io_open)
 		{
-			if (xio_open(connection->io, connection_on_io_open_complete, connection_on_bytes_received, connection_on_io_error, connection) != 0)
+			if (xio_open(connection->io, connection_on_io_open_complete, connection, connection_on_bytes_received, connection, connection_on_io_error, connection) != 0)
 			{
 				connection_set_state(connection, CONNECTION_STATE_END);
 				result = __LINE__;
diff --git a/src/header_detect_io.c b/src/header_detect_io.c
@@ -23,8 +23,10 @@ typedef struct HEADER_DETECT_IO_INSTANCE_TAG
 	ON_IO_CLOSE_COMPLETE on_io_close_complete;
 	ON_IO_ERROR on_io_error;
 	ON_BYTES_RECEIVED on_bytes_received;
-	void* open_callback_context;
-	void* close_callback_context;
+	void* on_io_open_complete_context;
+	void* on_io_close_complete_context;
+    void* on_io_error_context;
+    void* on_bytes_received_context;
 } HEADER_DETECT_IO_INSTANCE;
 
 static const unsigned char amqp_header[] = { 'A', 'M', 'Q', 'P', 0, 1, 0, 0 };
@@ -33,18 +35,26 @@ static void indicate_error(HEADER_DETECT_IO_INSTANCE* header_detect_io_instance)
 {
 	if (header_detect_io_instance->on_io_error != NULL)
 	{
-		header_detect_io_instance->on_io_error(header_detect_io_instance->open_callback_context);
+		header_detect_io_instance->on_io_error(header_detect_io_instance->on_io_error_context);
 	}
 }
 
 static void indicate_open_complete(HEADER_DETECT_IO_INSTANCE* header_detect_io_instance, IO_OPEN_RESULT open_result)
 {
 	if (header_detect_io_instance->on_io_open_complete != NULL)
 	{
-		header_detect_io_instance->on_io_open_complete(header_detect_io_instance->open_callback_context, open_result);
+		header_detect_io_instance->on_io_open_complete(header_detect_io_instance->on_io_open_complete_context, open_result);
 	}
 }
 
+static void indicate_close_complete(HEADER_DETECT_IO_INSTANCE* header_detect_io_instance)
+{
+    if (header_detect_io_instance->on_io_close_complete != NULL)
+    {
+        header_detect_io_instance->on_io_close_complete(header_detect_io_instance->on_io_close_complete_context);
+    }
+}
+
 static void on_underlying_io_bytes_received(void* context, const unsigned char* buffer, size_t size)
 {
 	HEADER_DETECT_IO_INSTANCE* header_detect_io_instance = (HEADER_DETECT_IO_INSTANCE*)context;
@@ -85,7 +95,7 @@ static void on_underlying_io_bytes_received(void* context, const unsigned char*
 			break;
 
 		case IO_STATE_OPEN:
-			header_detect_io_instance->on_bytes_received(header_detect_io_instance->open_callback_context, buffer, size);
+			header_detect_io_instance->on_bytes_received(header_detect_io_instance->on_bytes_received_context, buffer, size);
 			size = 0;
 			break;
 		}
@@ -101,6 +111,11 @@ static void on_underlying_io_close_complete(void* context)
 	default:
 		break;
 
+    case IO_STATE_CLOSING:
+        header_detect_io_instance->io_state = IO_STATE_NOT_OPEN;
+        indicate_close_complete(header_detect_io_instance);
+        break;
+
 	case IO_STATE_WAIT_FOR_HEADER:
 	case IO_STATE_OPENING_UNDERLYING_IO:
 		header_detect_io_instance->io_state = IO_STATE_NOT_OPEN;
@@ -174,9 +189,13 @@ CONCRETE_IO_HANDLE headerdetectio_create(void* io_create_parameters, LOGGER_LOG
 		{
 			result->underlying_io = header_detect_io_config->underlying_io;
 			result->on_io_open_complete = NULL;
+            result->on_io_close_complete = NULL;
 			result->on_io_error = NULL;
 			result->on_bytes_received = NULL;
-			result->open_callback_context = NULL;
+			result->on_io_open_complete_context = NULL;
+            result->on_io_close_complete_context = NULL;
+            result->on_io_error_context = NULL;
+            result->on_bytes_received_context = NULL;
 
 			result->io_state = IO_STATE_NOT_OPEN;
 		}
@@ -196,7 +215,7 @@ void headerdetectio_destroy(CONCRETE_IO_HANDLE header_detect_io)
 	}
 }
 
-int headerdetectio_open(CONCRETE_IO_HANDLE header_detect_io, ON_IO_OPEN_COMPLETE on_io_open_complete, ON_BYTES_RECEIVED on_bytes_received, ON_IO_ERROR on_io_error, void* callback_context)
+int headerdetectio_open(CONCRETE_IO_HANDLE header_detect_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context)
 {
 	int result;
 
@@ -213,7 +232,9 @@ int headerdetectio_open(CONCRETE_IO_HANDLE header_detect_io, ON_IO_OPEN_COMPLETE
 			header_detect_io_instance->on_bytes_received = on_bytes_received;
 			header_detect_io_instance->on_io_open_complete = on_io_open_complete;
 			header_detect_io_instance->on_io_error = on_io_error;
-			header_detect_io_instance->open_callback_context = callback_context;
+            header_detect_io_instance->on_bytes_received_context = on_bytes_received_context;
+            header_detect_io_instance->on_io_open_complete_context = on_io_open_complete_context;
+            header_detect_io_instance->on_io_error_context = on_io_error_context;
 
 			result = 0;
 		}
@@ -226,7 +247,7 @@ int headerdetectio_open(CONCRETE_IO_HANDLE header_detect_io, ON_IO_OPEN_COMPLETE
 			header_detect_io_instance->header_pos = 0;
 			header_detect_io_instance->io_state = IO_STATE_OPENING_UNDERLYING_IO;
 
-			if (xio_open(header_detect_io_instance->underlying_io, on_underlying_io_open_complete, on_underlying_io_bytes_received, on_underlying_io_error, header_detect_io_instance) != 0)
+			if (xio_open(header_detect_io_instance->underlying_io, on_underlying_io_open_complete, header_detect_io_instance, on_underlying_io_bytes_received, header_detect_io_instance, on_underlying_io_error, header_detect_io_instance) != 0)
 			{
 				result = __LINE__;
 			}
@@ -260,6 +281,8 @@ int headerdetectio_close(CONCRETE_IO_HANDLE header_detect_io, ON_IO_CLOSE_COMPLE
 		else
 		{
 			header_detect_io_instance->io_state = IO_STATE_CLOSING;
+            header_detect_io_instance->on_io_close_complete = on_io_close_complete;
+            header_detect_io_instance->on_io_close_complete_context = callback_context;
 
 			if (xio_close(header_detect_io_instance->underlying_io, on_underlying_io_close_complete, header_detect_io_instance) != 0)
 			{
diff --git a/src/saslclientio.c b/src/saslclientio.c
@@ -53,8 +53,10 @@ typedef struct SASL_CLIENT_IO_INSTANCE_TAG
 	ON_IO_OPEN_COMPLETE on_io_open_complete;
 	ON_IO_CLOSE_COMPLETE on_io_close_complete;
 	ON_IO_ERROR on_io_error;
-	void* open_callback_context;
-	void* close_callback_context;
+    void* on_bytes_received_context;
+	void* on_io_open_complete_context;
+	void* on_io_close_complete_context;
+    void* on_io_error_context;
 	LOGGER_LOG logger_log;
 	SASL_HEADER_EXCHANGE_STATE sasl_header_exchange_state;
 	SASL_CLIENT_NEGOTIATION_STATE sasl_client_negotiation_state;
@@ -75,23 +77,23 @@ static void indicate_error(SASL_CLIENT_IO_INSTANCE* sasl_client_io_instance)
 {
 	if (sasl_client_io_instance->on_io_error != NULL)
 	{
-		sasl_client_io_instance->on_io_error(sasl_client_io_instance->open_callback_context);
+		sasl_client_io_instance->on_io_error(sasl_client_io_instance->on_io_error_context);
 	}
 }
 
 static void indicate_open_complete(SASL_CLIENT_IO_INSTANCE* sasl_client_io_instance, IO_OPEN_RESULT open_result)
 {
 	if (sasl_client_io_instance->on_io_open_complete != NULL)
 	{
-		sasl_client_io_instance->on_io_open_complete(sasl_client_io_instance->open_callback_context, open_result);
+		sasl_client_io_instance->on_io_open_complete(sasl_client_io_instance->on_io_open_complete_context, open_result);
 	}
 }
 
 static void indicate_close_complete(SASL_CLIENT_IO_INSTANCE* sasl_client_io_instance)
 {
 	if (sasl_client_io_instance->on_io_close_complete != NULL)
 	{
-		sasl_client_io_instance->on_io_close_complete(sasl_client_io_instance->close_callback_context);
+		sasl_client_io_instance->on_io_close_complete(sasl_client_io_instance->on_io_close_complete_context);
 	}
 }
 
@@ -328,7 +330,7 @@ static int saslclientio_receive_byte(SASL_CLIENT_IO_INSTANCE* sasl_client_io_ins
 			break;
 
 		case SASL_CLIENT_NEGOTIATION_OUTCOME_RCVD:
-			sasl_client_io_instance->on_bytes_received(sasl_client_io_instance->open_callback_context, &b, 1);
+			sasl_client_io_instance->on_bytes_received(sasl_client_io_instance->on_bytes_received_context, &b, 1);
 			result = 0;
 			break;
 		}
@@ -408,7 +410,7 @@ static void on_underlying_io_bytes_received(void* context, const unsigned char*
 		case IO_STATE_OPEN:
 			/* Codes_SRS_SASLCLIENTIO_01_027: [When the on_bytes_received callback passed to the underlying IO is called and the SASL client IO state is IO_STATE_OPEN, the bytes shall be indicated to the user of SASL client IO by calling the on_bytes_received that was passed in saslclientio_open.] */
 			/* Codes_SRS_SASLCLIENTIO_01_029: [The context argument shall be set to the callback_context passed in saslclientio_open.] */
-			sasl_client_io_instance->on_bytes_received(sasl_client_io_instance->open_callback_context, buffer, size);
+			sasl_client_io_instance->on_bytes_received(sasl_client_io_instance->on_bytes_received_context, buffer, size);
 			break;
 
 		case IO_STATE_SASL_HANDSHAKE:
@@ -885,8 +887,10 @@ CONCRETE_IO_HANDLE saslclientio_create(void* io_create_parameters, LOGGER_LOG lo
 						result->on_io_error = NULL;
 						result->on_io_close_complete = NULL;
 						result->logger_log = logger_log;
-						result->open_callback_context = NULL;
-						result->close_callback_context = NULL;
+                        result->on_bytes_received_context = NULL;
+						result->on_io_open_complete_context = NULL;
+						result->on_io_close_complete_context = NULL;
+                        result->on_io_error_context = NULL;
 						result->sasl_mechanism = sasl_client_io_config->sasl_mechanism;
 
 						result->io_state = IO_STATE_NOT_OPEN;
@@ -915,7 +919,7 @@ void saslclientio_destroy(CONCRETE_IO_HANDLE sasl_client_io)
 	}
 }
 
-int saslclientio_open(CONCRETE_IO_HANDLE sasl_client_io, ON_IO_OPEN_COMPLETE on_io_open_complete, ON_BYTES_RECEIVED on_bytes_received, ON_IO_ERROR on_io_error, void* callback_context)
+int saslclientio_open(CONCRETE_IO_HANDLE sasl_client_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context)
 {
 	int result = 0;
 
@@ -938,15 +942,17 @@ int saslclientio_open(CONCRETE_IO_HANDLE sasl_client_io, ON_IO_OPEN_COMPLETE on_
 			sasl_client_io_instance->on_bytes_received = on_bytes_received;
 			sasl_client_io_instance->on_io_open_complete = on_io_open_complete;
 			sasl_client_io_instance->on_io_error = on_io_error;
-			sasl_client_io_instance->open_callback_context = callback_context;
+			sasl_client_io_instance->on_bytes_received_context = on_bytes_received_context;
+            sasl_client_io_instance->on_io_open_complete_context = on_io_open_complete_context;
+            sasl_client_io_instance->on_io_error_context = on_io_error_context;
 			sasl_client_io_instance->sasl_header_exchange_state = SASL_HEADER_EXCHANGE_IDLE;
 			sasl_client_io_instance->sasl_client_negotiation_state = SASL_CLIENT_NEGOTIATION_NOT_STARTED;
 			sasl_client_io_instance->header_bytes_received = 0;
 			sasl_client_io_instance->io_state = IO_STATE_OPENING_UNDERLYING_IO;
 
 			/* Codes_SRS_SASLCLIENTIO_01_009: [saslclientio_open shall call xio_open on the underlying_io passed to saslclientio_create.] */
 			/* Codes_SRS_SASLCLIENTIO_01_013: [saslclientio_open shall pass to xio_open a callback for receiving bytes and a state changed callback for the underlying_io state changes.] */
-			if (xio_open(sasl_client_io_instance->underlying_io, on_underlying_io_open_complete, on_underlying_io_bytes_received, on_underlying_io_error, sasl_client_io_instance) != 0)
+			if (xio_open(sasl_client_io_instance->underlying_io, on_underlying_io_open_complete, sasl_client_io_instance, on_underlying_io_bytes_received, sasl_client_io_instance, on_underlying_io_error, sasl_client_io_instance) != 0)
 			{
 				/* Codes_SRS_SASLCLIENTIO_01_012: [If the open of the underlying_io fails, saslclientio_open shall fail and return non-zero value.] */
 				result = __LINE__;
diff --git a/tests/connection_unittests/connection_unittests.cpp b/tests/connection_unittests/connection_unittests.cpp
@@ -91,11 +91,11 @@ TYPED_MOCK_CLASS(connection_mocks, CGlobalMock)
 	MOCK_METHOD_END(XIO_HANDLE, TEST_IO_HANDLE);
 	MOCK_STATIC_METHOD_1(, void, xio_destroy, XIO_HANDLE, xio)
 	MOCK_VOID_METHOD_END();
-	MOCK_STATIC_METHOD_5(, int, xio_open, XIO_HANDLE, io, ON_IO_OPEN_COMPLETE, on_io_open_complete, ON_BYTES_RECEIVED, on_bytes_received, ON_IO_ERROR, on_io_error, void*, callback_context)
+	MOCK_STATIC_METHOD_7(, int, xio_open, XIO_HANDLE, io, ON_IO_OPEN_COMPLETE, on_io_open_complete, void*, on_io_open_complete_context, ON_BYTES_RECEIVED, on_bytes_received, void*, on_bytes_received_context, ON_IO_ERROR, on_io_error, void*, on_io_error_context)
 		saved_on_bytes_received = on_bytes_received;
 		saved_on_io_open_complete = on_io_open_complete;
 		saved_on_io_error = on_io_error;
-		saved_io_callback_context = callback_context;
+		saved_io_callback_context = on_io_open_complete_context;
 	MOCK_METHOD_END(int, 0);
 	MOCK_STATIC_METHOD_3(, int, xio_close, XIO_HANDLE, xio, ON_IO_CLOSE_COMPLETE, on_io_close_complete, void*, callback_context)
 	MOCK_METHOD_END(int, 0);
@@ -212,7 +212,7 @@ extern "C"
 {
 	DECLARE_GLOBAL_MOCK_METHOD_3(connection_mocks, , XIO_HANDLE, xio_create, const IO_INTERFACE_DESCRIPTION*, io_interface_description, const void*, io_create_parameters, LOGGER_LOG, logger_log);
 	DECLARE_GLOBAL_MOCK_METHOD_1(connection_mocks, , void, xio_destroy, XIO_HANDLE, xio);
-	DECLARE_GLOBAL_MOCK_METHOD_5(connection_mocks, , int, xio_open, XIO_HANDLE, xio, ON_IO_OPEN_COMPLETE, on_io_open_complete, ON_BYTES_RECEIVED, on_bytes_received, ON_IO_ERROR, on_io_error, void*, callback_context);
+	DECLARE_GLOBAL_MOCK_METHOD_7(connection_mocks, , int, xio_open, XIO_HANDLE, xio, ON_IO_OPEN_COMPLETE, on_io_open_complete, void*, on_io_open_complete_context, ON_BYTES_RECEIVED, on_bytes_received, void*, on_bytes_received_context, ON_IO_ERROR, on_io_error, void*, on_io_error_context);
 	DECLARE_GLOBAL_MOCK_METHOD_3(connection_mocks, , int, xio_close, XIO_HANDLE, xio, ON_IO_CLOSE_COMPLETE, on_io_close_complete, void*, callback_context);
 	DECLARE_GLOBAL_MOCK_METHOD_5(connection_mocks, , int, xio_send, XIO_HANDLE, xio, const void*, buffer, size_t, size, ON_SEND_COMPLETE, on_send_complete, void*, callback_context);
 	DECLARE_GLOBAL_MOCK_METHOD_1(connection_mocks, , void, xio_dowork, XIO_HANDLE, xio);
diff --git a/tests/saslclientio_unittests/saslclientio_unittests.cpp b/tests/saslclientio_unittests/saslclientio_unittests.cpp
@@ -147,11 +147,11 @@ TYPED_MOCK_CLASS(saslclientio_mocks, CGlobalMock)
 	MOCK_METHOD_END(int, 0);
 
 	/* xio mocks */
-	MOCK_STATIC_METHOD_5(, int, xio_open, XIO_HANDLE, xio, ON_IO_OPEN_COMPLETE, on_io_open_complete, ON_BYTES_RECEIVED, on_bytes_received, ON_IO_ERROR, on_io_error, void*, callback_context)
+	MOCK_STATIC_METHOD_7(, int, xio_open, XIO_HANDLE, xio, ON_IO_OPEN_COMPLETE, on_io_open_complete, void*, on_io_open_complete_context, ON_BYTES_RECEIVED, on_bytes_received, void*, on_bytes_received_context, ON_IO_ERROR, on_io_error, void*, on_io_error_context)
 		saved_on_bytes_received = on_bytes_received;
 		saved_on_io_open_complete = on_io_open_complete;
 		saved_on_io_error = on_io_error;
-		saved_io_callback_context = callback_context;
+		saved_io_callback_context = on_io_open_complete_context;
 	MOCK_METHOD_END(int, 0);
 	MOCK_STATIC_METHOD_3(, int, xio_close, XIO_HANDLE, xio, ON_IO_CLOSE_COMPLETE, on_io_close_complete, void*, callback_context)
 	MOCK_METHOD_END(int, 0);
@@ -218,7 +218,7 @@ extern "C"
 	DECLARE_GLOBAL_MOCK_METHOD_1(saslclientio_mocks, , void, sasl_frame_codec_destroy, SASL_FRAME_CODEC_HANDLE, sasl_frame_codec);
 	DECLARE_GLOBAL_MOCK_METHOD_4(saslclientio_mocks, , int, sasl_frame_codec_encode_frame, SASL_FRAME_CODEC_HANDLE, sasl_frame_codec, const AMQP_VALUE, sasl_frame_value, ON_BYTES_ENCODED, on_bytes_encoded, void*, callback_context)
 
-	DECLARE_GLOBAL_MOCK_METHOD_5(saslclientio_mocks, , int, xio_open, XIO_HANDLE, xio, ON_IO_OPEN_COMPLETE, on_io_open_complete, ON_BYTES_RECEIVED, on_bytes_received, ON_IO_ERROR, on_io_error, void*, callback_context);
+	DECLARE_GLOBAL_MOCK_METHOD_7(saslclientio_mocks, , int, xio_open, XIO_HANDLE, xio, ON_IO_OPEN_COMPLETE, on_io_open_complete, void*, on_io_open_complete_context, ON_BYTES_RECEIVED, on_bytes_received, void*, on_bytes_received_context, ON_IO_ERROR, on_io_error, void*, on_io_error_context);
 	DECLARE_GLOBAL_MOCK_METHOD_3(saslclientio_mocks, , int, xio_close, XIO_HANDLE, xio, ON_IO_CLOSE_COMPLETE, on_io_close_complete, void*, callback_context);
 	DECLARE_GLOBAL_MOCK_METHOD_5(saslclientio_mocks, , int, xio_send, XIO_HANDLE, xio, const void*, buffer, size_t, size, ON_SEND_COMPLETE, on_send_complete, void*, callback_context);
 	DECLARE_GLOBAL_MOCK_METHOD_1(saslclientio_mocks, , void, xio_dowork, XIO_HANDLE, xio);

Original file line number	Diff line number	Diff line change
`@@ -1016,7 +1016,7 @@ int connection_open(CONNECTION_HANDLE connection)`
`1016`	`1016`	`{`
`1017`	`1017`	`if (!connection->is_underlying_io_open)`
`1018`	`1018`	`{`
`1019`		`- if (xio_open(connection->io, connection_on_io_open_complete, connection_on_bytes_received, connection_on_io_error, connection) != 0)`
	`1019`	`+ if (xio_open(connection->io, connection_on_io_open_complete, connection, connection_on_bytes_received, connection, connection_on_io_error, connection) != 0)`
`1020`	`1020`	`{`
`1021`	`1021`	`connection_set_state(connection, CONNECTION_STATE_END);`
`1022`	`1022`	`result = __LINE__;`
`@@ -1051,7 +1051,7 @@ int connection_listen(CONNECTION_HANDLE connection)`
`1051`	`1051`	`{`
`1052`	`1052`	`if (!connection->is_underlying_io_open)`
`1053`	`1053`	`{`
`1054`		`- if (xio_open(connection->io, connection_on_io_open_complete, connection_on_bytes_received, connection_on_io_error, connection) != 0)`
	`1054`	`+ if (xio_open(connection->io, connection_on_io_open_complete, connection, connection_on_bytes_received, connection, connection_on_io_error, connection) != 0)`
`1055`	`1055`	`{`
`1056`	`1056`	`connection_set_state(connection, CONNECTION_STATE_END);`
`1057`	`1057`	`result = __LINE__;`
Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,10 @@ typedef struct HEADER_DETECT_IO_INSTANCE_TAG`
`23`	`23`	`ON_IO_CLOSE_COMPLETE on_io_close_complete;`
`24`	`24`	`ON_IO_ERROR on_io_error;`
`25`	`25`	`ON_BYTES_RECEIVED on_bytes_received;`
`26`		`- void* open_callback_context;`
`27`		`- void* close_callback_context;`
	`26`	`+ void* on_io_open_complete_context;`
	`27`	`+ void* on_io_close_complete_context;`
	`28`	`+ void* on_io_error_context;`
	`29`	`+ void* on_bytes_received_context;`
`28`	`30`	`} HEADER_DETECT_IO_INSTANCE;`
`29`	`31`
`30`	`32`	`static const unsigned char amqp_header[] = { 'A', 'M', 'Q', 'P', 0, 1, 0, 0 };`
`@@ -33,18 +35,26 @@ static void indicate_error(HEADER_DETECT_IO_INSTANCE* header_detect_io_instance)`
`33`	`35`	`{`
`34`	`36`	`if (header_detect_io_instance->on_io_error != NULL)`
`35`	`37`	`{`
`36`		`- header_detect_io_instance->on_io_error(header_detect_io_instance->open_callback_context);`
	`38`	`+ header_detect_io_instance->on_io_error(header_detect_io_instance->on_io_error_context);`
`37`	`39`	`}`
`38`	`40`	`}`
`39`	`41`
`40`	`42`	`static void indicate_open_complete(HEADER_DETECT_IO_INSTANCE* header_detect_io_instance, IO_OPEN_RESULT open_result)`
`41`	`43`	`{`
`42`	`44`	`if (header_detect_io_instance->on_io_open_complete != NULL)`
`43`	`45`	`{`
`44`		`- header_detect_io_instance->on_io_open_complete(header_detect_io_instance->open_callback_context, open_result);`
	`46`	`+ header_detect_io_instance->on_io_open_complete(header_detect_io_instance->on_io_open_complete_context, open_result);`
`45`	`47`	`}`
`46`	`48`	`}`
`47`	`49`
	`50`	`+static void indicate_close_complete(HEADER_DETECT_IO_INSTANCE* header_detect_io_instance)`
	`51`	`+{`
	`52`	`+ if (header_detect_io_instance->on_io_close_complete != NULL)`
	`53`	`+ {`
	`54`	`+ header_detect_io_instance->on_io_close_complete(header_detect_io_instance->on_io_close_complete_context);`
	`55`	`+ }`
	`56`	`+}`
	`57`	`+`
`48`	`58`	`static void on_underlying_io_bytes_received(void* context, const unsigned char* buffer, size_t size)`
`49`	`59`	`{`
`50`	`60`	`HEADER_DETECT_IO_INSTANCE* header_detect_io_instance = (HEADER_DETECT_IO_INSTANCE*)context;`
`@@ -85,7 +95,7 @@ static void on_underlying_io_bytes_received(void* context, const unsigned char*`
`85`	`95`	`break;`
`86`	`96`
`87`	`97`	`case IO_STATE_OPEN:`
`88`		`- header_detect_io_instance->on_bytes_received(header_detect_io_instance->open_callback_context, buffer, size);`
	`98`	`+ header_detect_io_instance->on_bytes_received(header_detect_io_instance->on_bytes_received_context, buffer, size);`
`89`	`99`	`size = 0;`
`90`	`100`	`break;`
`91`	`101`	`}`
`@@ -101,6 +111,11 @@ static void on_underlying_io_close_complete(void* context)`
`101`	`111`	`default:`
`102`	`112`	`break;`
`103`	`113`
	`114`	`+ case IO_STATE_CLOSING:`
	`115`	`+ header_detect_io_instance->io_state = IO_STATE_NOT_OPEN;`
	`116`	`+ indicate_close_complete(header_detect_io_instance);`
	`117`	`+ break;`
	`118`	`+`
`104`	`119`	`case IO_STATE_WAIT_FOR_HEADER:`
`105`	`120`	`case IO_STATE_OPENING_UNDERLYING_IO:`
`106`	`121`	`header_detect_io_instance->io_state = IO_STATE_NOT_OPEN;`
`@@ -174,9 +189,13 @@ CONCRETE_IO_HANDLE headerdetectio_create(void* io_create_parameters, LOGGER_LOG`
`174`	`189`	`{`
`175`	`190`	`result->underlying_io = header_detect_io_config->underlying_io;`
`176`	`191`	`result->on_io_open_complete = NULL;`
	`192`	`+ result->on_io_close_complete = NULL;`
`177`	`193`	`result->on_io_error = NULL;`
`178`	`194`	`result->on_bytes_received = NULL;`
`179`		`- result->open_callback_context = NULL;`
	`195`	`+ result->on_io_open_complete_context = NULL;`
	`196`	`+ result->on_io_close_complete_context = NULL;`
	`197`	`+ result->on_io_error_context = NULL;`
	`198`	`+ result->on_bytes_received_context = NULL;`
`180`	`199`
`181`	`200`	`result->io_state = IO_STATE_NOT_OPEN;`
`182`	`201`	`}`
`@@ -196,7 +215,7 @@ void headerdetectio_destroy(CONCRETE_IO_HANDLE header_detect_io)`
`196`	`215`	`}`
`197`	`216`	`}`
`198`	`217`
`199`		`-int headerdetectio_open(CONCRETE_IO_HANDLE header_detect_io, ON_IO_OPEN_COMPLETE on_io_open_complete, ON_BYTES_RECEIVED on_bytes_received, ON_IO_ERROR on_io_error, void* callback_context)`
	`218`	`+int headerdetectio_open(CONCRETE_IO_HANDLE header_detect_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context)`
`200`	`219`	`{`
`201`	`220`	`int result;`
`202`	`221`
`@@ -213,7 +232,9 @@ int headerdetectio_open(CONCRETE_IO_HANDLE header_detect_io, ON_IO_OPEN_COMPLETE`
`213`	`232`	`header_detect_io_instance->on_bytes_received = on_bytes_received;`
`214`	`233`	`header_detect_io_instance->on_io_open_complete = on_io_open_complete;`
`215`	`234`	`header_detect_io_instance->on_io_error = on_io_error;`
`216`		`- header_detect_io_instance->open_callback_context = callback_context;`
	`235`	`+ header_detect_io_instance->on_bytes_received_context = on_bytes_received_context;`
	`236`	`+ header_detect_io_instance->on_io_open_complete_context = on_io_open_complete_context;`
	`237`	`+ header_detect_io_instance->on_io_error_context = on_io_error_context;`
`217`	`238`
`218`	`239`	`result = 0;`
`219`	`240`	`}`
`@@ -226,7 +247,7 @@ int headerdetectio_open(CONCRETE_IO_HANDLE header_detect_io, ON_IO_OPEN_COMPLETE`
`226`	`247`	`header_detect_io_instance->header_pos = 0;`
`227`	`248`	`header_detect_io_instance->io_state = IO_STATE_OPENING_UNDERLYING_IO;`
`228`	`249`
`229`		`- if (xio_open(header_detect_io_instance->underlying_io, on_underlying_io_open_complete, on_underlying_io_bytes_received, on_underlying_io_error, header_detect_io_instance) != 0)`
	`250`	`+ if (xio_open(header_detect_io_instance->underlying_io, on_underlying_io_open_complete, header_detect_io_instance, on_underlying_io_bytes_received, header_detect_io_instance, on_underlying_io_error, header_detect_io_instance) != 0)`
`230`	`251`	`{`
`231`	`252`	`result = __LINE__;`
`232`	`253`	`}`
`@@ -260,6 +281,8 @@ int headerdetectio_close(CONCRETE_IO_HANDLE header_detect_io, ON_IO_CLOSE_COMPLE`
`260`	`281`	`else`
`261`	`282`	`{`
`262`	`283`	`header_detect_io_instance->io_state = IO_STATE_CLOSING;`
	`284`	`+ header_detect_io_instance->on_io_close_complete = on_io_close_complete;`
	`285`	`+ header_detect_io_instance->on_io_close_complete_context = callback_context;`
`263`	`286`
`264`	`287`	`if (xio_close(header_detect_io_instance->underlying_io, on_underlying_io_close_complete, header_detect_io_instance) != 0)`
`265`	`288`	`{`
Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,10 @@ typedef struct SASL_CLIENT_IO_INSTANCE_TAG`
`53`	`53`	`ON_IO_OPEN_COMPLETE on_io_open_complete;`
`54`	`54`	`ON_IO_CLOSE_COMPLETE on_io_close_complete;`
`55`	`55`	`ON_IO_ERROR on_io_error;`
`56`		`- void* open_callback_context;`
`57`		`- void* close_callback_context;`
	`56`	`+ void* on_bytes_received_context;`
	`57`	`+ void* on_io_open_complete_context;`
	`58`	`+ void* on_io_close_complete_context;`
	`59`	`+ void* on_io_error_context;`
`58`	`60`	`LOGGER_LOG logger_log;`
`59`	`61`	`SASL_HEADER_EXCHANGE_STATE sasl_header_exchange_state;`
`60`	`62`	`SASL_CLIENT_NEGOTIATION_STATE sasl_client_negotiation_state;`
`@@ -75,23 +77,23 @@ static void indicate_error(SASL_CLIENT_IO_INSTANCE* sasl_client_io_instance)`
`75`	`77`	`{`
`76`	`78`	`if (sasl_client_io_instance->on_io_error != NULL)`
`77`	`79`	`{`
`78`		`- sasl_client_io_instance->on_io_error(sasl_client_io_instance->open_callback_context);`
	`80`	`+ sasl_client_io_instance->on_io_error(sasl_client_io_instance->on_io_error_context);`
`79`	`81`	`}`
`80`	`82`	`}`
`81`	`83`
`82`	`84`	`static void indicate_open_complete(SASL_CLIENT_IO_INSTANCE* sasl_client_io_instance, IO_OPEN_RESULT open_result)`
`83`	`85`	`{`
`84`	`86`	`if (sasl_client_io_instance->on_io_open_complete != NULL)`
`85`	`87`	`{`
`86`		`- sasl_client_io_instance->on_io_open_complete(sasl_client_io_instance->open_callback_context, open_result);`
	`88`	`+ sasl_client_io_instance->on_io_open_complete(sasl_client_io_instance->on_io_open_complete_context, open_result);`
`87`	`89`	`}`
`88`	`90`	`}`
`89`	`91`
`90`	`92`	`static void indicate_close_complete(SASL_CLIENT_IO_INSTANCE* sasl_client_io_instance)`
`91`	`93`	`{`
`92`	`94`	`if (sasl_client_io_instance->on_io_close_complete != NULL)`
`93`	`95`	`{`
`94`		`- sasl_client_io_instance->on_io_close_complete(sasl_client_io_instance->close_callback_context);`
	`96`	`+ sasl_client_io_instance->on_io_close_complete(sasl_client_io_instance->on_io_close_complete_context);`
`95`	`97`	`}`
`96`	`98`	`}`
`97`	`99`
`@@ -328,7 +330,7 @@ static int saslclientio_receive_byte(SASL_CLIENT_IO_INSTANCE* sasl_client_io_ins`
`328`	`330`	`break;`
`329`	`331`
`330`	`332`	`case SASL_CLIENT_NEGOTIATION_OUTCOME_RCVD:`
`331`		`- sasl_client_io_instance->on_bytes_received(sasl_client_io_instance->open_callback_context, &b, 1);`
	`333`	`+ sasl_client_io_instance->on_bytes_received(sasl_client_io_instance->on_bytes_received_context, &b, 1);`
`332`	`334`	`result = 0;`
`333`	`335`	`break;`
`334`	`336`	`}`
`@@ -408,7 +410,7 @@ static void on_underlying_io_bytes_received(void* context, const unsigned char*`
`408`	`410`	`case IO_STATE_OPEN:`
`409`	`411`	`/* Codes_SRS_SASLCLIENTIO_01_027: [When the on_bytes_received callback passed to the underlying IO is called and the SASL client IO state is IO_STATE_OPEN, the bytes shall be indicated to the user of SASL client IO by calling the on_bytes_received that was passed in saslclientio_open.] */`
`410`	`412`	`/* Codes_SRS_SASLCLIENTIO_01_029: [The context argument shall be set to the callback_context passed in saslclientio_open.] */`
`411`		`- sasl_client_io_instance->on_bytes_received(sasl_client_io_instance->open_callback_context, buffer, size);`
	`413`	`+ sasl_client_io_instance->on_bytes_received(sasl_client_io_instance->on_bytes_received_context, buffer, size);`
`412`	`414`	`break;`
`413`	`415`
`414`	`416`	`case IO_STATE_SASL_HANDSHAKE:`
`@@ -885,8 +887,10 @@ CONCRETE_IO_HANDLE saslclientio_create(void* io_create_parameters, LOGGER_LOG lo`
`885`	`887`	`result->on_io_error = NULL;`
`886`	`888`	`result->on_io_close_complete = NULL;`
`887`	`889`	`result->logger_log = logger_log;`
`888`		`- result->open_callback_context = NULL;`
`889`		`- result->close_callback_context = NULL;`
	`890`	`+ result->on_bytes_received_context = NULL;`
	`891`	`+ result->on_io_open_complete_context = NULL;`
	`892`	`+ result->on_io_close_complete_context = NULL;`
	`893`	`+ result->on_io_error_context = NULL;`
`890`	`894`	`result->sasl_mechanism = sasl_client_io_config->sasl_mechanism;`
`891`	`895`
`892`	`896`	`result->io_state = IO_STATE_NOT_OPEN;`
`@@ -915,7 +919,7 @@ void saslclientio_destroy(CONCRETE_IO_HANDLE sasl_client_io)`
`915`	`919`	`}`
`916`	`920`	`}`
`917`	`921`
`918`		`-int saslclientio_open(CONCRETE_IO_HANDLE sasl_client_io, ON_IO_OPEN_COMPLETE on_io_open_complete, ON_BYTES_RECEIVED on_bytes_received, ON_IO_ERROR on_io_error, void* callback_context)`
	`922`	`+int saslclientio_open(CONCRETE_IO_HANDLE sasl_client_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context)`
`919`	`923`	`{`
`920`	`924`	`int result = 0;`
`921`	`925`
`@@ -938,15 +942,17 @@ int saslclientio_open(CONCRETE_IO_HANDLE sasl_client_io, ON_IO_OPEN_COMPLETE on_`
`938`	`942`	`sasl_client_io_instance->on_bytes_received = on_bytes_received;`
`939`	`943`	`sasl_client_io_instance->on_io_open_complete = on_io_open_complete;`
`940`	`944`	`sasl_client_io_instance->on_io_error = on_io_error;`
`941`		`- sasl_client_io_instance->open_callback_context = callback_context;`
	`945`	`+ sasl_client_io_instance->on_bytes_received_context = on_bytes_received_context;`
	`946`	`+ sasl_client_io_instance->on_io_open_complete_context = on_io_open_complete_context;`
	`947`	`+ sasl_client_io_instance->on_io_error_context = on_io_error_context;`
`942`	`948`	`sasl_client_io_instance->sasl_header_exchange_state = SASL_HEADER_EXCHANGE_IDLE;`
`943`	`949`	`sasl_client_io_instance->sasl_client_negotiation_state = SASL_CLIENT_NEGOTIATION_NOT_STARTED;`
`944`	`950`	`sasl_client_io_instance->header_bytes_received = 0;`
`945`	`951`	`sasl_client_io_instance->io_state = IO_STATE_OPENING_UNDERLYING_IO;`
`946`	`952`
`947`	`953`	`/* Codes_SRS_SASLCLIENTIO_01_009: [saslclientio_open shall call xio_open on the underlying_io passed to saslclientio_create.] */`
`948`	`954`	`/* Codes_SRS_SASLCLIENTIO_01_013: [saslclientio_open shall pass to xio_open a callback for receiving bytes and a state changed callback for the underlying_io state changes.] */`
`949`		`- if (xio_open(sasl_client_io_instance->underlying_io, on_underlying_io_open_complete, on_underlying_io_bytes_received, on_underlying_io_error, sasl_client_io_instance) != 0)`
	`955`	`+ if (xio_open(sasl_client_io_instance->underlying_io, on_underlying_io_open_complete, sasl_client_io_instance, on_underlying_io_bytes_received, sasl_client_io_instance, on_underlying_io_error, sasl_client_io_instance) != 0)`
`950`	`956`	`{`
`951`	`957`	`/* Codes_SRS_SASLCLIENTIO_01_012: [If the open of the underlying_io fails, saslclientio_open shall fail and return non-zero value.] */`
`952`	`958`	`result = __LINE__;`